@supernova123/docker-mcp-server 0.1.0

package/dist/tools/health.js

@@ -0,0 +1,129 @@
+import { CheckHealthSchema, WatchHealthSchema, SetRestartPolicySchema } from "../types.js";
+import { formatError } from "../docker.js";
+export function registerHealthTools(server, docker) {
+    server.tool("check_health", "Run a health probe against a container. Supports HTTP, TCP, and exec probes. Auto-detects from container HEALTHCHECK if available.", CheckHealthSchema.shape, async (params) => {
+        try {
+            const container = docker.getContainer(params.container_id);
+            const info = await container.inspect();
+            // Check if container has HEALTHCHECK
+            const healthcheck = info.Config.Healthcheck;
+            let probeType = params.type;
+            let endpoint = params.endpoint;
+            let command = params.command;
+            if (!probeType && healthcheck?.Test?.length) {
+                const test = healthcheck.Test[0];
+                if (test.startsWith("CMD ")) {
+                    probeType = "exec";
+                    command = test.slice(4).split(" ");
+                }
+                else if (test.startsWith("CMD-SHELL ")) {
+                    probeType = "exec";
+                    command = ["sh", "-c", test.slice(10)];
+                }
+                else if (test === "NONE") {
+                    probeType = undefined;
+                }
+            }
+            if (!probeType) {
+                return {
+                    content: [{ type: "text", text: "No health check configured for this container and no probe type specified." }],
+                };
+            }
+            if (probeType === "exec" && command) {
+                const exec = await container.exec({
+                    Cmd: command,
+                    AttachStdout: true,
+                    AttachStderr: true,
+                });
+                const stream = await exec.start({});
+                const output = await new Promise((resolve) => {
+                    let data = "";
+                    stream.on("data", (chunk) => { data += chunk.toString(); });
+                    stream.on("end", () => resolve(data));
+                });
+                const inspect = await exec.inspect();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                healthy: inspect.ExitCode === 0,
+                                exitCode: inspect.ExitCode,
+                                output: output.trim(),
+                            }, null, 2),
+                        }],
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Health probe type '${probeType}' is not yet implemented in v1. Use exec probes or check container HEALTHCHECK directly.` }],
+                isError: true,
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+    server.tool("watch_health", "Poll a container's health status until it becomes healthy or times out. Useful for waiting on service startup.", WatchHealthSchema.shape, async (params) => {
+        try {
+            const container = docker.getContainer(params.container_id);
+            const timeout = (params.timeout ?? 60) * 1000;
+            const interval = (params.interval ?? 5) * 1000;
+            const start = Date.now();
+            while (Date.now() - start < timeout) {
+                const info = await container.inspect();
+                const health = info.State.Health;
+                if (health?.Status === "healthy") {
+                    return {
+                        content: [{ type: "text", text: JSON.stringify({ healthy: true, status: "healthy", waitTime: Date.now() - start }, null, 2) }],
+                    };
+                }
+                if (health?.Status === "unhealthy") {
+                    const lastLog = health.Log?.[health.Log.length - 1];
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    healthy: false,
+                                    status: "unhealthy",
+                                    exitCode: lastLog?.ExitCode,
+                                    output: lastLog?.Output?.trim(),
+                                }, null, 2),
+                            }],
+                    };
+                }
+                await new Promise((resolve) => setTimeout(resolve, interval));
+            }
+            const info = await container.inspect();
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            healthy: false,
+                            status: "timeout",
+                            containerHealth: info.State.Health?.Status ?? "no healthcheck",
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+    server.tool("set_restart_policy", "Change the restart policy of a running container without recreating it.", SetRestartPolicySchema.shape, async (params) => {
+        try {
+            const container = docker.getContainer(params.container_id);
+            await container.update({
+                RestartPolicy: {
+                    Name: params.policy,
+                    MaximumRetryCount: params.max_retry_count ?? 0,
+                },
+            });
+            return {
+                content: [{ type: "text", text: `Restart policy set to '${params.policy}' for container ${params.container_id}.` }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+}
+//# sourceMappingURL=health.js.map

package/dist/tools/image.d.ts

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

package/dist/tools/image.js

@@ -0,0 +1,67 @@
+import { ListImagesSchema, PullImageSchema, BuildImageSchema, RemoveImageSchema, } from "../types.js";
+import { formatImage, formatError } 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, async (params) => {
+        try {
+            const images = await docker.listImages({
+                all: params.all ?? false,
+                filters: params.filter ? JSON.stringify({ reference: [params.filter] }) : undefined,
+            });
+            const results = images.map(formatImage);
+            return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+    server.tool("pull_image", "Pull a Docker image from a registry. Returns pull progress events.", PullImageSchema.shape, async (params) => {
+        try {
+            const imageRef = params.tag ? `${params.image}:${params.tag}` : params.image;
+            const stream = await docker.pull(imageRef);
+            // Wait for pull to complete
+            await new Promise((resolve, reject) => {
+                docker.modem.followProgress(stream, (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+            return { content: [{ type: "text", text: `Image ${imageRef} pulled successfully.` }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+    server.tool("build_image", "Build a Docker image from a Dockerfile or build context path.", BuildImageSchema.shape, async (params) => {
+        try {
+            const stream = await docker.buildImage({
+                context: params.context,
+                src: [params.dockerfile ?? "Dockerfile"],
+            }, { t: params.tag, dockerfile: params.dockerfile, buildargs: params.build_args, target: params.target });
+            await new Promise((resolve, reject) => {
+                docker.modem.followProgress(stream, (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+            return { content: [{ type: "text", text: `Image ${params.tag} built successfully.` }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+    server.tool("remove_image", "Remove a Docker image by name or ID. Use force to remove even if tagged.", RemoveImageSchema.shape, async (params) => {
+        try {
+            const image = docker.getImage(params.image);
+            await image.remove({ force: params.force ?? false });
+            return { content: [{ type: "text", text: `Image ${params.image} removed.` }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+}
+//# sourceMappingURL=image.js.map

package/dist/tools/logs.d.ts

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

package/dist/tools/logs.js

@@ -0,0 +1,69 @@
+import { StreamLogsSchema, ContainerStatsSchema } from "../types.js";
+import { formatError, formatBytes } from "../docker.js";
+export function registerLogsTools(server, docker) {
+    server.tool("stream_logs", "Get logs from a Docker container. Supports tail count, timestamp filtering, and follow mode.", StreamLogsSchema.shape, async (params) => {
+        try {
+            const container = docker.getContainer(params.container_id);
+            const logs = await container.logs({
+                stdout: true,
+                stderr: true,
+                tail: params.tail ?? 100,
+                since: params.since ? Math.floor(new Date(params.since).getTime() / 1000) : undefined,
+                follow: false,
+            });
+            // Dockerode returns a Buffer with multiplexed stream headers
+            const output = logs.toString("utf-8").replace(/^[\x00-\x0f]{8}/gm, "");
+            return { content: [{ type: "text", text: output || "No logs found." }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+    server.tool("container_stats", "Get real-time resource usage statistics for a Docker container (CPU, memory, network, I/O).", ContainerStatsSchema.shape, async (params) => {
+        try {
+            const container = docker.getContainer(params.container_id);
+            const stats = await container.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 ?? 0;
+            const memPercent = memLimit > 0 ? (memUsage / memLimit) * 100 : 0;
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            name: params.container_id,
+                            cpu: {
+                                percent: parseFloat(cpuPercent.toFixed(2)),
+                                cores: cpuCount,
+                            },
+                            memory: {
+                                usage: formatBytes(memUsage),
+                                limit: formatBytes(memLimit),
+                                percent: parseFloat(memPercent.toFixed(2)),
+                            },
+                            network: stats.networks
+                                ? Object.fromEntries(Object.entries(stats.networks).map(([iface, data]) => [
+                                    iface,
+                                    {
+                                        rx: formatBytes(data.rx_bytes ?? 0),
+                                        tx: formatBytes(data.tx_bytes ?? 0),
+                                    },
+                                ]))
+                                : {},
+                            blockIO: {
+                                read: formatBytes(stats.blkio_stats?.io_service_bytes?.[0]?.value ?? 0),
+                                write: formatBytes(stats.blkio_stats?.io_service_bytes?.[1]?.value ?? 0),
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+}
+//# sourceMappingURL=logs.js.map

package/dist/tools/network.d.ts

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

package/dist/tools/network.js

@@ -0,0 +1,47 @@
+import { ListNetworksSchema, ListVolumesSchema } from "../types.js";
+import { formatError } 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, async (params) => {
+        try {
+            const networks = await docker.listNetworks({
+                filters: params.filter ? JSON.stringify({ name: [params.filter] }) : undefined,
+            });
+            const results = networks.map((n) => ({
+                id: n.Id.substring(0, 12),
+                name: n.Name,
+                driver: n.Driver,
+                scope: n.Scope,
+                created: n.Created,
+                containers: n.Containers
+                    ? Object.fromEntries(Object.entries(n.Containers).map(([id, c]) => [
+                        id.substring(0, 12),
+                        { name: c.Name, ipv4: c.IPv4Address },
+                    ]))
+                    : {},
+            }));
+            return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+    server.tool("list_volumes", "List Docker volumes with optional filter. Returns volume names, drivers, mount points, and labels.", ListVolumesSchema.shape, async (params) => {
+        try {
+            const result = await docker.listVolumes({
+                filters: params.filter ? JSON.stringify({ name: [params.filter] }) : undefined,
+            });
+            const volumes = (result.Volumes || []).map((v) => ({
+                name: v.Name,
+                driver: v.Driver,
+                mountpoint: v.Mountpoint,
+                created: v.CreatedAt ?? v.Created,
+                labels: v.Labels,
+            }));
+            return { content: [{ type: "text", text: JSON.stringify(volumes, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
+        }
+    });
+}
+//# sourceMappingURL=network.js.map

package/dist/types.d.ts

@@ -0,0 +1,309 @@
+import { z } from "zod";
+export declare const ListContainersSchema: z.ZodObject<{
+    all: z.ZodOptional<z.ZodBoolean>;
+    label: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    name: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodEnum<["running", "stopped", "paused", "exited", "created", "restarting"]>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    state?: "created" | "running" | "stopped" | "paused" | "exited" | "restarting" | undefined;
+    all?: boolean | 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;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+}, {
+    container_id: string;
+}>;
+export declare const StartContainerSchema: z.ZodObject<{
+    container_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+}, {
+    container_id: string;
+}>;
+export declare const StopContainerSchema: z.ZodObject<{
+    container_id: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+    timeout?: number | undefined;
+}, {
+    container_id: string;
+    timeout?: number | undefined;
+}>;
+export declare const RestartContainerSchema: z.ZodObject<{
+    container_id: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+    timeout?: number | undefined;
+}, {
+    container_id: string;
+    timeout?: number | undefined;
+}>;
+export declare const RemoveContainerSchema: z.ZodObject<{
+    container_id: z.ZodString;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+    force?: boolean | undefined;
+}, {
+    container_id: string;
+    force?: boolean | undefined;
+}>;
+export declare const RecreateContainerSchema: z.ZodObject<{
+    container_id: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+    timeout?: number | undefined;
+}, {
+    container_id: string;
+    timeout?: number | undefined;
+}>;
+export declare const RunContainerSchema: z.ZodObject<{
+    image: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    ports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    volumes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    restart_policy: z.ZodOptional<z.ZodEnum<["no", "always", "unless-stopped", "on-failure"]>>;
+    command: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    detach: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    image: string;
+    name?: string | undefined;
+    ports?: Record<string, string> | undefined;
+    env?: Record<string, string> | undefined;
+    volumes?: string[] | undefined;
+    restart_policy?: "no" | "always" | "unless-stopped" | "on-failure" | undefined;
+    command?: string[] | undefined;
+    detach?: boolean | undefined;
+}, {
+    image: string;
+    name?: string | undefined;
+    ports?: Record<string, string> | undefined;
+    env?: Record<string, string> | undefined;
+    volumes?: string[] | undefined;
+    restart_policy?: "no" | "always" | "unless-stopped" | "on-failure" | undefined;
+    command?: string[] | undefined;
+    detach?: boolean | undefined;
+}>;
+export declare const ListImagesSchema: z.ZodObject<{
+    all: z.ZodOptional<z.ZodBoolean>;
+    filter: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: string | undefined;
+    all?: boolean | undefined;
+}, {
+    filter?: string | undefined;
+    all?: boolean | undefined;
+}>;
+export declare const PullImageSchema: z.ZodObject<{
+    image: z.ZodString;
+    tag: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    image: string;
+    tag?: string | undefined;
+}, {
+    image: string;
+    tag?: string | undefined;
+}>;
+export declare const BuildImageSchema: z.ZodObject<{
+    context: z.ZodString;
+    tag: z.ZodString;
+    dockerfile: z.ZodOptional<z.ZodString>;
+    build_args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    target: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    tag: string;
+    context: string;
+    dockerfile?: string | undefined;
+    build_args?: Record<string, string> | undefined;
+    target?: string | undefined;
+}, {
+    tag: string;
+    context: string;
+    dockerfile?: string | undefined;
+    build_args?: Record<string, string> | undefined;
+    target?: string | undefined;
+}>;
+export declare const RemoveImageSchema: z.ZodObject<{
+    image: z.ZodString;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    image: string;
+    force?: boolean | undefined;
+}, {
+    image: string;
+    force?: boolean | undefined;
+}>;
+export declare const ComposeUpSchema: z.ZodObject<{
+    path: z.ZodString;
+    build: z.ZodOptional<z.ZodBoolean>;
+    detach: z.ZodOptional<z.ZodBoolean>;
+    services: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    detach?: boolean | undefined;
+    build?: boolean | undefined;
+    services?: string[] | undefined;
+}, {
+    path: string;
+    detach?: boolean | undefined;
+    build?: boolean | undefined;
+    services?: string[] | undefined;
+}>;
+export declare const ComposeDownSchema: z.ZodObject<{
+    path: z.ZodString;
+    volumes: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    timeout?: number | undefined;
+    volumes?: boolean | undefined;
+}, {
+    path: string;
+    timeout?: number | undefined;
+    volumes?: boolean | undefined;
+}>;
+export declare const ComposePsSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export declare const ComposeLogsSchema: z.ZodObject<{
+    path: z.ZodString;
+    services: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tail: z.ZodOptional<z.ZodNumber>;
+    follow: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    services?: string[] | undefined;
+    tail?: number | undefined;
+    follow?: boolean | undefined;
+}, {
+    path: string;
+    services?: string[] | undefined;
+    tail?: number | undefined;
+    follow?: boolean | undefined;
+}>;
+export declare const ComposeRestartSchema: z.ZodObject<{
+    path: z.ZodString;
+    services: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    timeout?: number | undefined;
+    services?: string[] | undefined;
+}, {
+    path: string;
+    timeout?: number | undefined;
+    services?: string[] | undefined;
+}>;
+export declare const CheckHealthSchema: z.ZodObject<{
+    container_id: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<["http", "tcp", "exec"]>>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+    type?: "http" | "tcp" | "exec" | undefined;
+    command?: string[] | undefined;
+    endpoint?: string | undefined;
+}, {
+    container_id: string;
+    type?: "http" | "tcp" | "exec" | undefined;
+    command?: string[] | undefined;
+    endpoint?: string | undefined;
+}>;
+export declare const WatchHealthSchema: z.ZodObject<{
+    container_id: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    interval: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+    timeout?: number | undefined;
+    interval?: number | undefined;
+}, {
+    container_id: string;
+    timeout?: number | undefined;
+    interval?: number | undefined;
+}>;
+export declare const SetRestartPolicySchema: z.ZodObject<{
+    container_id: z.ZodString;
+    policy: z.ZodEnum<["no", "always", "unless-stopped", "on-failure"]>;
+    max_retry_count: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+    policy: "no" | "always" | "unless-stopped" | "on-failure";
+    max_retry_count?: number | undefined;
+}, {
+    container_id: string;
+    policy: "no" | "always" | "unless-stopped" | "on-failure";
+    max_retry_count?: number | undefined;
+}>;
+export declare const StreamLogsSchema: z.ZodObject<{
+    container_id: z.ZodString;
+    tail: z.ZodOptional<z.ZodNumber>;
+    since: z.ZodOptional<z.ZodString>;
+    follow: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+    tail?: number | undefined;
+    follow?: boolean | undefined;
+    since?: string | undefined;
+}, {
+    container_id: string;
+    tail?: number | undefined;
+    follow?: boolean | undefined;
+    since?: string | undefined;
+}>;
+export declare const ContainerStatsSchema: z.ZodObject<{
+    container_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+}, {
+    container_id: string;
+}>;
+export declare const ExecInContainerSchema: z.ZodObject<{
+    container_id: z.ZodString;
+    command: z.ZodArray<z.ZodString, "many">;
+    working_dir: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    container_id: string;
+    command: string[];
+    env?: Record<string, string> | undefined;
+    working_dir?: string | undefined;
+}, {
+    container_id: string;
+    command: string[];
+    env?: Record<string, string> | undefined;
+    working_dir?: string | undefined;
+}>;
+export declare const ListNetworksSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: string | undefined;
+}, {
+    filter?: string | undefined;
+}>;
+export declare const ListVolumesSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: string | undefined;
+}, {
+    filter?: string | undefined;
+}>;
+//# sourceMappingURL=types.d.ts.map