@mseep/mcp-swarmpit 0.1.0

package/src/tools/stacks.ts

@@ -0,0 +1,282 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import type { RedactMode } from "../config.js";
+import { SwarmpitClient } from "../client.js";
+import { sanitizeServices, sanitizeComposeYaml, resolveComposeEnvRefs, restoreRedactedValues } from "../sanitize.js";
+import { toolResult, toolError, resolveData } from "./helpers.js";
+
+export function registerStackTools(
+  server: McpServer,
+  client: SwarmpitClient,
+  redact: RedactMode
+): void {
+  server.tool(
+    "list_stacks",
+    "List all Docker Swarm stacks",
+    {},
+    async () => {
+      try {
+        const stacks = await client.listStacks();
+        return toolResult(stacks);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_stack",
+    "Get stack details including services and compose file",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        const [services, file] = await Promise.all([
+          client.getStackServices(name),
+          client.getStackFile(name).catch(() => ({ compose: "" })),
+        ]);
+        if (redact === "none") {
+          return toolResult({ name, services, compose: file.compose });
+        }
+        const redactAll = redact === "all";
+        return toolResult({
+          name,
+          services: sanitizeServices(services, redactAll),
+          compose: sanitizeComposeYaml(file.compose, redactAll),
+        });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  const composeInput = z.union([
+    z.string(),
+    z.object({ $file: z.string() }).describe('Read compose from local file path'),
+  ]);
+
+  server.tool(
+    "create_stack",
+    "Create a new Docker Swarm stack from compose YAML. Use $env:VAR_NAME for secret values, or { $file: /path } to read from a local file.",
+    {
+      name: z.string().describe("Stack name"),
+      compose: composeInput.describe("Compose YAML string or { $file: /path }"),
+    },
+    async ({ name, compose }) => {
+      try {
+        const yaml = resolveData(compose);
+        const resolved = resolveComposeEnvRefs(yaml);
+        await client.createStack({ name, spec: { compose: resolved } });
+        return toolResult({ created: true, name });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "update_stack",
+    "Update a Docker Swarm stack. [REDACTED] values are preserved. Use $env:VAR_NAME for new secrets, or { $file: /path } to read from a local file.",
+    {
+      name: z.string().describe("Stack name"),
+      compose: composeInput.describe("Compose YAML string or { $file: /path }. Leave [REDACTED] for unchanged secrets."),
+    },
+    async ({ name, compose }) => {
+      try {
+        const yaml = resolveData(compose);
+        const current = await client.getStackFile(name).catch(() => ({ compose: "" }));
+        const restored = restoreRedactedValues(yaml, current.compose);
+        const resolved = resolveComposeEnvRefs(restored);
+        await client.updateStack(name, resolved);
+        return toolResult({ updated: true, name });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "redeploy_stack",
+    "Redeploy all services in a Docker Swarm stack",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        await client.redeployStack(name);
+        return toolResult({ redeployed: true, name });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "rollback_stack",
+    "Rollback all services in a Docker Swarm stack to their previous version",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        await client.rollbackStack(name);
+        return toolResult({ rolledBack: true, name });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "deactivate_stack",
+    "Deactivate (stop) all services in a Docker Swarm stack",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        await client.deactivateStack(name);
+        return toolResult({ deactivated: true, name });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "delete_stack",
+    "Delete a Docker Swarm stack. DESTRUCTIVE: requires confirm=true",
+    {
+      name: z.string().describe("Stack name"),
+      confirm: z.boolean().describe("Must be true to confirm deletion"),
+    },
+    async ({ name, confirm }) => {
+      if (!confirm) {
+        return toolError("Destructive operation: set confirm=true to delete this stack");
+      }
+      try {
+        await client.deleteStack(name);
+        return toolResult({ deleted: true, name });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_stack_tasks",
+    "List all tasks (containers) in a stack",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        const tasks = await client.getStackTasks(name);
+        return toolResult(tasks);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_stack_volumes",
+    "List all volumes in a stack",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        const volumes = await client.getStackVolumes(name);
+        return toolResult(volumes);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_stack_networks",
+    "List all networks in a stack",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        const networks = await client.getStackNetworks(name);
+        return toolResult(networks);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_stack_compose",
+    "Get the generated compose YAML for a stack",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        const compose = await client.getStackCompose(name);
+        if (redact === "none") return toolResult(compose);
+        return toolResult({ compose: sanitizeComposeYaml(compose.compose, redact === "all") });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_stack_secrets",
+    "List all secrets in a stack",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        const secrets = await client.getStackSecrets(name);
+        return toolResult(secrets);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_stack_configs",
+    "List all configs in a stack",
+    { name: z.string().describe("Stack name") },
+    async ({ name }) => {
+      try {
+        const configs = await client.getStackConfigs(name);
+        return toolResult(configs);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "create_stack_file",
+    "Upload/create a compose file for a stack. Accepts a string or { $file: /path }.",
+    {
+      name: z.string().describe("Stack name"),
+      compose: composeInput.describe("Compose YAML string or { $file: /path }"),
+    },
+    async ({ name, compose }) => {
+      try {
+        const yaml = resolveData(compose);
+        const resolved = resolveComposeEnvRefs(yaml);
+        await client.createStackFile(name, resolved);
+        return toolResult({ created: true, name });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "delete_stack_file",
+    "Delete the compose file for a stack. DESTRUCTIVE: requires confirm=true",
+    {
+      name: z.string().describe("Stack name"),
+      confirm: z.boolean().describe("Must be true to confirm deletion"),
+    },
+    async ({ name, confirm }) => {
+      if (!confirm) {
+        return toolError("Destructive operation: set confirm=true to delete this stack file");
+      }
+      try {
+        await client.deleteStackFile(name);
+        return toolResult({ deleted: true, name });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+}

package/src/tools/tasks.ts

@@ -0,0 +1,37 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { SwarmpitClient } from "../client.js";
+import { toolResult, toolError } from "./helpers.js";
+
+export function registerTaskTools(
+  server: McpServer,
+  client: SwarmpitClient
+): void {
+  server.tool(
+    "list_tasks",
+    "List all Docker Swarm tasks across all services",
+    {},
+    async () => {
+      try {
+        const tasks = await client.listTasks();
+        return toolResult(tasks);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_task",
+    "Get details of a specific Docker Swarm task",
+    { id: z.string().describe("Task ID") },
+    async ({ id }) => {
+      try {
+        const task = await client.getTask(id);
+        return toolResult(task);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+}

package/src/tools/timeseries.ts

@@ -0,0 +1,65 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { SwarmpitClient } from "../client.js";
+import { toolResult, toolError } from "./helpers.js";
+
+export function registerTimeseriesTools(
+  server: McpServer,
+  client: SwarmpitClient
+): void {
+  server.tool(
+    "get_nodes_timeseries",
+    "Get timeseries data for all nodes (CPU, memory, disk over time)",
+    {},
+    async () => {
+      try {
+        const ts = await client.getNodesTimeseries();
+        return toolResult(ts);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_services_cpu_timeseries",
+    "Get CPU usage timeseries for all services",
+    {},
+    async () => {
+      try {
+        const ts = await client.getServicesCpuTimeseries();
+        return toolResult(ts);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_services_memory_timeseries",
+    "Get memory usage timeseries for all services",
+    {},
+    async () => {
+      try {
+        const ts = await client.getServicesMemoryTimeseries();
+        return toolResult(ts);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_task_timeseries",
+    "Get timeseries data for a specific task",
+    { name: z.string().describe("Task name") },
+    async ({ name }) => {
+      try {
+        const ts = await client.getTaskTimeseries(name);
+        return toolResult(ts);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+}

package/src/tools/util.ts

@@ -0,0 +1,20 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SwarmpitConfig } from "../config.js";
+import { toolResult } from "./helpers.js";
+
+export function registerUtilTools(
+  server: McpServer,
+  config: SwarmpitConfig
+): void {
+  server.tool(
+    "swarmpit_info",
+    "Show the connected Swarmpit instance URL and redaction mode",
+    {},
+    async () => {
+      return toolResult({
+        url: config.url,
+        redact: config.redact,
+      });
+    }
+  );
+}

package/src/tools/volumes.ts

@@ -0,0 +1,88 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { SwarmpitClient } from "../client.js";
+import { toolResult, toolError } from "./helpers.js";
+
+export function registerVolumeTools(
+  server: McpServer,
+  client: SwarmpitClient
+): void {
+  server.tool(
+    "list_volumes",
+    "List all Docker Swarm volumes",
+    {},
+    async () => {
+      try {
+        const volumes = await client.listVolumes();
+        return toolResult(volumes);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_volume",
+    "Get details of a specific Docker Swarm volume",
+    { name: z.string().describe("Volume name") },
+    async ({ name }) => {
+      try {
+        const volume = await client.getVolume(name);
+        return toolResult(volume);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "create_volume",
+    "Create a Docker Swarm volume",
+    {
+      volumeName: z.string().describe("Volume name"),
+      driver: z.string().default("local").describe("Volume driver (default: local)"),
+    },
+    async ({ volumeName, driver }) => {
+      try {
+        await client.createVolume({ volumeName, driver, options: [] });
+        return toolResult({ created: true, volumeName });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "delete_volume",
+    "Delete a Docker Swarm volume. DESTRUCTIVE: requires confirm=true",
+    {
+      name: z.string().describe("Volume name"),
+      confirm: z.boolean().describe("Must be true to confirm deletion"),
+    },
+    async ({ name, confirm }) => {
+      if (!confirm) {
+        return toolError("Destructive operation: set confirm=true to delete this volume");
+      }
+      try {
+        await client.deleteVolume(name);
+        return toolResult({ deleted: true, name });
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+
+  server.tool(
+    "get_volume_services",
+    "List services using a specific volume",
+    { name: z.string().describe("Volume name") },
+    async ({ name }) => {
+      try {
+        const services = await client.getVolumeServices(name);
+        return toolResult(services);
+      } catch (e) {
+        return toolError(e);
+      }
+    }
+  );
+}

package/src/types.ts

@@ -0,0 +1,131 @@
+export interface SwarmpitPort {
+  containerPort: number;
+  hostPort: number;
+  protocol: string;
+  mode: string;
+}
+
+export interface SwarmpitMount {
+  containerPath: string;
+  host: string;
+  type: string;
+  readOnly: boolean;
+}
+
+export interface SwarmpitEnvVar {
+  name: string;
+  value: string;
+}
+
+export interface SwarmpitLabel {
+  name: string;
+  value: string;
+}
+
+export interface SwarmpitSecretRef {
+  id: string;
+  secretName: string;
+  secretTarget: string;
+}
+
+export interface SwarmpitConfigRef {
+  id: string;
+  configName: string;
+  configTarget: string;
+}
+
+export interface SwarmpitRepository {
+  name: string;
+  tag: string;
+  image: string;
+  imageDigest: string;
+}
+
+export interface SwarmpitResources {
+  cpu: number;
+  memory: number;
+}
+
+export interface SwarmpitServiceStatus {
+  tasks: { running: number; total: number };
+  update: string;
+  message: string;
+}
+
+export interface SwarmpitService {
+  id: string;
+  version: number;
+  createdAt: string;
+  updatedAt: string;
+  repository: SwarmpitRepository;
+  serviceName: string;
+  mode: string;
+  replicas: number;
+  state: string;
+  status: SwarmpitServiceStatus;
+  ports: SwarmpitPort[];
+  mounts: SwarmpitMount[];
+  networks: SwarmpitNetwork[];
+  secrets: SwarmpitSecretRef[];
+  configs: SwarmpitConfigRef[];
+  variables: SwarmpitEnvVar[];
+  labels: SwarmpitLabel[];
+  command: string[] | null;
+  stack: string;
+  resources: {
+    reservation: SwarmpitResources;
+    limit: SwarmpitResources;
+  };
+}
+
+export interface SwarmpitStack {
+  stackName: string;
+  stackFile: string;
+  services: SwarmpitService[];
+}
+
+export interface SwarmpitNetwork {
+  id: string;
+  networkName: string;
+  driver: string;
+  scope: string;
+  internal: boolean;
+  stack: string;
+}
+
+export interface SwarmpitNode {
+  id: string;
+  nodeName: string;
+  role: string;
+  state: string;
+  availability: string;
+  address: string;
+  engine: string;
+}
+
+export interface SwarmpitTask {
+  id: string;
+  taskName: string;
+  serviceName: string;
+  state: string;
+  status: string;
+  desiredState: string;
+  createdAt: string;
+  repository: SwarmpitRepository;
+  nodeName: string;
+  nodeId: string;
+}
+
+export interface SwarmpitVolume {
+  volumeName: string;
+  driver: string;
+  scope: string;
+  stack: string;
+  mountpoint: string;
+}
+
+export interface SwarmpitLogEntry {
+  line: string;
+  timestamp?: string;
+  taskName?: string;
+}