@vibetools/dokploy-mcp 0.4.0

package/dist/tools/redis.js

@@ -0,0 +1,167 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── helpers ──────────────────────────────────────────────────────────
+const rdId = z.string().min(1).describe('Unique Redis database ID');
+const DB = 'redis';
+// ── tools ────────────────────────────────────────────────────────────
+const one = getTool({
+    name: `dokploy_${DB}_one`,
+    title: 'Get Redis Details',
+    description: 'Retrieve the full configuration and status details of a Redis database managed by Dokploy. Requires the unique Redis database ID. Returns all metadata including name, image, resource limits, environment variables, and current application status.',
+    schema: z.object({ redisId: rdId }).strict(),
+    endpoint: `${DB}.one`,
+});
+const create = postTool({
+    name: `dokploy_${DB}_create`,
+    title: 'Create Redis Database',
+    description: 'Create a new Redis database instance inside a Dokploy project. Requires a display name, app-level identifier, database password, and the target project ID. Optionally specify a Docker image, description, or remote server. Returns the newly created database record.',
+    schema: z
+        .object({
+        name: z.string().min(1).describe('Display name for the database'),
+        appName: z.string().min(1).describe('Unique app-level identifier'),
+        databasePassword: z.string().min(1).describe('Database password'),
+        projectId: z.string().min(1).describe('Project ID to create the database in'),
+        dockerImage: z.string().optional().describe('Docker image (default: redis:7)'),
+        description: z.string().nullable().optional().describe('Optional description'),
+        serverId: z.string().nullable().optional().describe('Target server ID (null for local)'),
+    })
+        .strict(),
+    endpoint: `${DB}.create`,
+});
+const update = postTool({
+    name: `dokploy_${DB}_update`,
+    title: 'Update Redis Database',
+    description: 'Update the configuration of an existing Redis database in Dokploy. Requires the Redis database ID and accepts optional fields such as name, Docker image, resource limits (memory and CPU), custom start command, environment variables, and external port. Returns the updated database configuration.',
+    schema: z
+        .object({
+        redisId: rdId,
+        name: z.string().min(1).optional().describe('Display name'),
+        appName: z.string().min(1).optional().describe('App-level identifier'),
+        description: z.string().nullable().optional().describe('Description'),
+        dockerImage: z.string().optional().describe('Docker image'),
+        memoryReservation: z.number().nullable().optional().describe('Memory reservation in MB'),
+        memoryLimit: z.number().nullable().optional().describe('Memory limit in MB'),
+        cpuReservation: z.number().nullable().optional().describe('CPU reservation'),
+        cpuLimit: z.number().nullable().optional().describe('CPU limit'),
+        command: z.string().nullable().optional().describe('Custom start command'),
+        env: z.string().nullable().optional().describe('Environment variables'),
+        externalPort: z.number().nullable().optional().describe('External port'),
+    })
+        .strict(),
+    endpoint: `${DB}.update`,
+});
+const remove = postTool({
+    name: `dokploy_${DB}_remove`,
+    title: 'Remove Redis Database',
+    description: 'Permanently delete a Redis database from Dokploy. Requires the Redis database ID. This is a destructive operation that removes the container, all associated data, and configuration. Returns the operation status confirming deletion.',
+    schema: z.object({ redisId: rdId }).strict(),
+    endpoint: `${DB}.remove`,
+    annotations: { destructiveHint: true },
+});
+const move = postTool({
+    name: `dokploy_${DB}_move`,
+    title: 'Move Redis Database',
+    description: 'Move a Redis database from its current project to a different project within Dokploy. Requires the Redis database ID and the destination project ID. The database configuration and data remain intact during the move. Returns the operation status.',
+    schema: z
+        .object({
+        redisId: rdId,
+        targetProjectId: z.string().min(1).describe('Destination project ID'),
+    })
+        .strict(),
+    endpoint: `${DB}.move`,
+});
+const deploy = postTool({
+    name: `dokploy_${DB}_deploy`,
+    title: 'Deploy Redis Database',
+    description: 'Deploy a Redis database in Dokploy, pulling the configured Docker image and starting the container. Requires the Redis database ID. This triggers a full deployment lifecycle including image pull, container creation, and startup. Returns the deployment operation status.',
+    schema: z.object({ redisId: rdId }).strict(),
+    endpoint: `${DB}.deploy`,
+});
+const start = postTool({
+    name: `dokploy_${DB}_start`,
+    title: 'Start Redis Database',
+    description: 'Start a previously stopped Redis database container in Dokploy. Requires the Redis database ID. The container will resume with its existing data and configuration. Returns the operation status.',
+    schema: z.object({ redisId: rdId }).strict(),
+    endpoint: `${DB}.start`,
+});
+const stop = postTool({
+    name: `dokploy_${DB}_stop`,
+    title: 'Stop Redis Database',
+    description: 'Stop a currently running Redis database container in Dokploy. Requires the Redis database ID. The container will be gracefully stopped but its data and configuration are preserved for future restarts. Returns the operation status.',
+    schema: z.object({ redisId: rdId }).strict(),
+    endpoint: `${DB}.stop`,
+    annotations: { destructiveHint: true },
+});
+const reload = postTool({
+    name: `dokploy_${DB}_reload`,
+    title: 'Reload Redis Database',
+    description: 'Reload the Redis database container in Dokploy without performing a full rebuild. Requires the Redis database ID and the app-level identifier. This restarts the container with its current configuration. Returns the operation status.',
+    schema: z
+        .object({
+        redisId: rdId,
+        appName: z.string().min(1).describe('App-level identifier'),
+    })
+        .strict(),
+    endpoint: `${DB}.reload`,
+});
+const rebuild = postTool({
+    name: `dokploy_${DB}_rebuild`,
+    title: 'Rebuild Redis Database',
+    description: 'Rebuild the Redis database container from scratch in Dokploy. Requires the Redis database ID. This tears down the existing container and recreates it using the current configuration, which is useful when the container state has become inconsistent. Returns the operation status.',
+    schema: z.object({ redisId: rdId }).strict(),
+    endpoint: `${DB}.rebuild`,
+});
+const changeStatus = postTool({
+    name: `dokploy_${DB}_change_status`,
+    title: 'Change Redis Status',
+    description: 'Manually set the application status of a Redis database in Dokploy. Requires the Redis database ID and the desired status (idle, running, done, or error). This is typically used for administrative overrides when the reported status does not match reality. Returns the updated status.',
+    schema: z
+        .object({
+        redisId: rdId,
+        applicationStatus: z
+            .enum(['idle', 'running', 'done', 'error'])
+            .describe('New application status'),
+    })
+        .strict(),
+    endpoint: `${DB}.changeStatus`,
+});
+const saveExternalPort = postTool({
+    name: `dokploy_${DB}_save_external_port`,
+    title: 'Save Redis External Port',
+    description: 'Set or clear the external port mapping for a Redis database in Dokploy. Requires the Redis database ID and the desired external port number, or null to remove the external port mapping. This controls whether the database is accessible from outside the Docker network. Returns the operation status.',
+    schema: z
+        .object({
+        redisId: rdId,
+        externalPort: z.number().nullable().describe('External port number (null to remove)'),
+    })
+        .strict(),
+    endpoint: `${DB}.saveExternalPort`,
+});
+const saveEnvironment = postTool({
+    name: `dokploy_${DB}_save_environment`,
+    title: 'Save Redis Environment',
+    description: 'Overwrite the environment variables for a Redis database in Dokploy. Requires the Redis database ID and the environment variables as a string. This replaces all existing environment variables with the provided values. Returns the operation status.',
+    schema: z
+        .object({
+        redisId: rdId,
+        env: z.string().nullable().optional().describe('Environment variables as a string'),
+    })
+        .strict(),
+    endpoint: `${DB}.saveEnvironment`,
+});
+// ── export ───────────────────────────────────────────────────────────
+export const redisTools = [
+    one,
+    create,
+    update,
+    remove,
+    move,
+    deploy,
+    start,
+    stop,
+    reload,
+    rebuild,
+    changeStatus,
+    saveExternalPort,
+    saveEnvironment,
+];

package/dist/tools/registry.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from './_factory.js';
+export declare const registryTools: ToolDefinition[];

package/dist/tools/registry.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── helpers ──────────────────────────────────────────────────────────
+const registryTypeEnum = z
+    .enum(['selfHosted', 'cloud'])
+    .describe('Registry type: selfHosted or cloud');
+const registryBaseSchema = {
+    registryName: z.string().min(1).describe('Name of the registry'),
+    username: z.string().min(1).describe('Registry username'),
+    password: z.string().min(1).describe('Registry password'),
+    registryUrl: z.string().min(1).describe('Registry URL'),
+    registryType: registryTypeEnum,
+    imagePrefix: z.string().nullable().optional().describe('Optional image prefix for the registry'),
+};
+// ── tools ────────────────────────────────────────────────────────────
+const all = getTool({
+    name: 'dokploy_registry_all',
+    title: 'List Registries',
+    description: 'List all container registries configured in Dokploy. Returns an array of registry objects including their names, URLs, types (selfHosted or cloud), and authentication details. Takes no parameters. Useful for reviewing which registries are available for deploying container images.',
+    schema: z.object({}).strict(),
+    endpoint: '/registry.all',
+});
+const one = getTool({
+    name: 'dokploy_registry_one',
+    title: 'Get Registry Details',
+    description: 'Get the full details of a specific container registry by its unique ID. Returns the registry name, URL, type, credentials, and image prefix configuration. Requires the registry ID. Useful for inspecting or verifying a registry setup before deploying.',
+    schema: z
+        .object({
+        registryId: z.string().min(1).describe('Unique registry ID'),
+    })
+        .strict(),
+    endpoint: '/registry.one',
+});
+const create = postTool({
+    name: 'dokploy_registry_create',
+    title: 'Create Registry',
+    description: 'Create a new container registry configuration in Dokploy. Requires the registry name, URL, username, password, and type (selfHosted or cloud). Optionally accepts an image prefix. Returns the newly created registry object.',
+    schema: z
+        .object({
+        ...registryBaseSchema,
+    })
+        .strict(),
+    endpoint: '/registry.create',
+});
+const update = postTool({
+    name: 'dokploy_registry_update',
+    title: 'Update Registry',
+    description: 'Update an existing container registry configuration in Dokploy. Requires the registry ID along with the updated name, URL, username, password, and type. Optionally accepts an image prefix. Returns the updated registry object.',
+    schema: z
+        .object({
+        registryId: z.string().min(1).describe('Unique registry ID to update'),
+        ...registryBaseSchema,
+    })
+        .strict(),
+    endpoint: '/registry.update',
+});
+const remove = postTool({
+    name: 'dokploy_registry_remove',
+    title: 'Remove Registry',
+    description: 'Permanently remove a container registry configuration from Dokploy. This action is irreversible and will delete all stored credentials for the registry. Requires the registry ID. Applications referencing this registry will need to be reconfigured.',
+    schema: z
+        .object({
+        registryId: z.string().min(1).describe('Unique registry ID to remove'),
+    })
+        .strict(),
+    endpoint: '/registry.remove',
+    annotations: { destructiveHint: true },
+});
+const testRegistry = postTool({
+    name: 'dokploy_registry_test',
+    title: 'Test Registry Connection',
+    description: 'Test the connection to a container registry using the provided credentials. Validates that Dokploy can authenticate and communicate with the registry. Requires the registry name, URL, username, password, and type. Returns a success or failure status.',
+    schema: z
+        .object({
+        ...registryBaseSchema,
+    })
+        .strict(),
+    endpoint: '/registry.testRegistry',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const registryTools = [all, one, create, update, remove, testRegistry];

package/dist/tools/security.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from './_factory.js';
+export declare const securityTools: ToolDefinition[];

package/dist/tools/security.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── helpers ──────────────────────────────────────────────────────────
+const securityId = z.string().min(1).describe('Unique security entry ID');
+// ── tools ────────────────────────────────────────────────────────────
+const one = getTool({
+    name: 'dokploy_security_one',
+    title: 'Get Security Entry',
+    description: 'Get details of a specific HTTP basic-auth security entry by its unique ID. Requires the securityId parameter. Returns the full security configuration including the associated application, username, and authentication settings.',
+    schema: z.object({ securityId }).strict(),
+    endpoint: '/security.one',
+});
+const create = postTool({
+    name: 'dokploy_security_create',
+    title: 'Create Security Entry',
+    description: 'Create a new HTTP basic-auth security entry to protect an application with username and password authentication. Requires the applicationId, username, and password parameters. Returns the newly created security entry with its assigned ID.',
+    schema: z
+        .object({
+        applicationId: z.string().min(1).describe('ID of the application to protect'),
+        username: z.string().min(1).describe('Username for basic-auth access'),
+        password: z.string().min(1).describe('Password for basic-auth access'),
+    })
+        .strict(),
+    endpoint: '/security.create',
+});
+const update = postTool({
+    name: 'dokploy_security_update',
+    title: 'Update Security Entry',
+    description: 'Update an existing HTTP basic-auth security entry by its ID. Requires the securityId and accepts optional username and password fields. Only provided fields will be updated; omitted fields remain unchanged. Returns the updated security entry.',
+    schema: z
+        .object({
+        securityId,
+        username: z.string().optional().describe('New username for basic-auth access'),
+        password: z.string().optional().describe('New password for basic-auth access'),
+    })
+        .strict(),
+    endpoint: '/security.update',
+});
+const deleteTool = postTool({
+    name: 'dokploy_security_delete',
+    title: 'Delete Security Entry',
+    description: 'Delete an HTTP basic-auth security entry permanently by its ID. This action is irreversible and will immediately remove authentication protection from the associated application. Requires the securityId parameter. Returns a confirmation of the deletion.',
+    schema: z.object({ securityId }).strict(),
+    endpoint: '/security.delete',
+    annotations: { destructiveHint: true },
+});
+// ── export ───────────────────────────────────────────────────────────
+export const securityTools = [one, create, update, deleteTool];

package/dist/tools/settings.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from './_factory.js';
+export declare const settingsTools: ToolDefinition[];

package/dist/tools/settings.js

@@ -0,0 +1,258 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── tools ────────────────────────────────────────────────────────────
+const reloadServer = postTool({
+    name: 'dokploy_settings_reload_server',
+    title: 'Reload Server',
+    description: 'Reload the Dokploy server process to apply configuration changes. No parameters required. Returns the reload status. Use after making changes to server settings that require a restart.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.reloadServer',
+});
+const reloadTraefik = postTool({
+    name: 'dokploy_settings_reload_traefik',
+    title: 'Reload Traefik',
+    description: 'Reload the Traefik reverse proxy to apply routing and configuration changes. No parameters required. Returns the reload status. Use after updating Traefik configuration, domains, or SSL certificates.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.reloadTraefik',
+});
+const cleanUnusedImages = postTool({
+    name: 'dokploy_settings_clean_unused_images',
+    title: 'Clean Unused Images',
+    description: 'Remove unused Docker images to free disk space on the server. No parameters required. Returns the amount of space reclaimed and the list of removed images. Only removes images not referenced by any container.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanUnusedImages',
+    annotations: { destructiveHint: true },
+});
+const cleanUnusedVolumes = postTool({
+    name: 'dokploy_settings_clean_unused_volumes',
+    title: 'Clean Unused Volumes',
+    description: 'Remove unused Docker volumes to free disk space. This action is irreversible and may delete persistent data stored in volumes not attached to any container. No parameters required. Returns the amount of space reclaimed and the list of removed volumes.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanUnusedVolumes',
+    annotations: { destructiveHint: true },
+});
+const cleanStoppedContainers = postTool({
+    name: 'dokploy_settings_clean_stopped_containers',
+    title: 'Clean Stopped Containers',
+    description: 'Remove all stopped Docker containers from the server. This action is irreversible and removes containers in exited or dead state. No parameters required. Returns the list of removed containers and space reclaimed.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanStoppedContainers',
+    annotations: { destructiveHint: true },
+});
+const cleanDockerBuilder = postTool({
+    name: 'dokploy_settings_clean_docker_builder',
+    title: 'Clean Docker Builder',
+    description: 'Clean the Docker builder cache to free disk space used by intermediate build layers. No parameters required. Returns the amount of space reclaimed. Safe to run without affecting running containers or images.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanDockerBuilder',
+    annotations: { destructiveHint: true },
+});
+const cleanDockerPrune = postTool({
+    name: 'dokploy_settings_clean_docker_prune',
+    title: 'Docker System Prune',
+    description: 'Run a full Docker system prune to remove all unused resources including stopped containers, dangling images, unused networks, and build cache. This action is irreversible. No parameters required. Returns the total space reclaimed.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanDockerPrune',
+    annotations: { destructiveHint: true },
+});
+const cleanAll = postTool({
+    name: 'dokploy_settings_clean_all',
+    title: 'Clean All Docker Resources',
+    description: 'Clean all unused Docker resources at once: images, volumes, stopped containers, and builder cache. This action is irreversible and is the most aggressive cleanup option. No parameters required. Returns a summary of all removed resources and total space reclaimed.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanAll',
+    annotations: { destructiveHint: true },
+});
+const cleanMonitoring = postTool({
+    name: 'dokploy_settings_clean_monitoring',
+    title: 'Clean Monitoring Data',
+    description: 'Clear all stored monitoring data including metrics and historical performance information. This action is irreversible and resets monitoring history to a clean state. No parameters required. Returns a confirmation of the cleanup.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanMonitoring',
+    annotations: { destructiveHint: true },
+});
+const saveSSHPrivateKey = postTool({
+    name: 'dokploy_settings_save_ssh_private_key',
+    title: 'Save SSH Private Key',
+    description: 'Save an SSH private key for server access and remote operations. Accepts the sshPrivateKey parameter containing the key content, or null to clear the stored key. Returns a confirmation that the key was saved successfully.',
+    schema: z
+        .object({
+        sshPrivateKey: z
+            .string()
+            .nullable()
+            .describe('The SSH private key content, or null to clear'),
+    })
+        .strict(),
+    endpoint: '/settings.saveSSHPrivateKey',
+});
+const cleanSSHPrivateKey = postTool({
+    name: 'dokploy_settings_clean_ssh_private_key',
+    title: 'Clean SSH Private Key',
+    description: 'Remove the stored SSH private key from the server. This action is irreversible and will prevent SSH-based remote operations until a new key is saved. No parameters required. Returns a confirmation of the removal.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanSSHPrivateKey',
+    annotations: { destructiveHint: true },
+});
+const assignDomainServer = postTool({
+    name: 'dokploy_settings_assign_domain_server',
+    title: 'Assign Domain to Server',
+    description: "Assign a domain to the Dokploy server with optional SSL certificate configuration. Accepts an optional letsEncryptEmail for Let's Encrypt certificate registration and an optional certificateType ('letsencrypt' or 'none'). Returns the updated domain assignment configuration.",
+    schema: z
+        .object({
+        letsEncryptEmail: z
+            .string()
+            .optional()
+            .describe("Email for Let's Encrypt certificate registration"),
+        certificateType: z
+            .enum(['letsencrypt', 'none'])
+            .optional()
+            .describe('Type of SSL certificate: letsencrypt or none'),
+    })
+        .strict(),
+    endpoint: '/settings.assignDomainServer',
+});
+const updateDockerCleanup = postTool({
+    name: 'dokploy_settings_update_docker_cleanup',
+    title: 'Update Docker Cleanup Schedule',
+    description: 'Configure automatic Docker cleanup scheduling to periodically remove unused resources. Requires the enabled boolean parameter and accepts an optional cron schedule expression. Returns the updated cleanup configuration.',
+    schema: z
+        .object({
+        enabled: z.boolean().describe('Whether automatic cleanup is enabled'),
+        schedule: z.string().optional().describe('Cron schedule expression for the cleanup job'),
+    })
+        .strict(),
+    endpoint: '/settings.updateDockerCleanup',
+});
+const readTraefikConfig = getTool({
+    name: 'dokploy_settings_read_traefik_config',
+    title: 'Read Traefik Config',
+    description: 'Read the current main Traefik configuration file content. No parameters required. Returns the raw Traefik configuration as a string, which defines the core routing, entrypoints, and provider settings.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.readTraefikConfig',
+});
+const updateTraefikConfig = postTool({
+    name: 'dokploy_settings_update_traefik_config',
+    title: 'Update Traefik Config',
+    description: 'Update the main Traefik configuration file with new content. Requires the traefikConfig parameter containing the full configuration. Returns a confirmation of the update. A Traefik reload may be needed to apply changes.',
+    schema: z
+        .object({
+        traefikConfig: z.string().min(1).describe('The new Traefik configuration content'),
+    })
+        .strict(),
+    endpoint: '/settings.updateTraefikConfig',
+});
+const readWebServerTraefikConfig = getTool({
+    name: 'dokploy_settings_read_web_server_traefik_config',
+    title: 'Read Web Server Traefik Config',
+    description: 'Read the Traefik configuration specific to the Dokploy web server. No parameters required. Returns the raw web server Traefik configuration as a string, which controls how the Dokploy dashboard and API are exposed.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.readWebServerTraefikConfig',
+});
+const updateWebServerTraefikConfig = postTool({
+    name: 'dokploy_settings_update_web_server_traefik_config',
+    title: 'Update Web Server Traefik Config',
+    description: 'Update the Traefik configuration for the Dokploy web server. Requires the traefikConfig parameter containing the full web server configuration. Returns a confirmation of the update. A Traefik reload may be needed to apply changes.',
+    schema: z
+        .object({
+        traefikConfig: z.string().min(1).describe('The new web server Traefik configuration content'),
+    })
+        .strict(),
+    endpoint: '/settings.updateWebServerTraefikConfig',
+});
+const readMiddlewareTraefikConfig = getTool({
+    name: 'dokploy_settings_read_middleware_traefik_config',
+    title: 'Read Middleware Traefik Config',
+    description: 'Read the Traefik middleware configuration that defines request processing rules such as rate limiting, authentication, and header manipulation. No parameters required. Returns the raw middleware configuration as a string.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.readMiddlewareTraefikConfig',
+});
+const updateMiddlewareTraefikConfig = postTool({
+    name: 'dokploy_settings_update_middleware_traefik_config',
+    title: 'Update Middleware Traefik Config',
+    description: 'Update the Traefik middleware configuration that controls request processing rules. Requires the traefikConfig parameter containing the full middleware configuration. Returns a confirmation of the update. A Traefik reload may be needed to apply changes.',
+    schema: z
+        .object({
+        traefikConfig: z.string().min(1).describe('The new middleware Traefik configuration content'),
+    })
+        .strict(),
+    endpoint: '/settings.updateMiddlewareTraefikConfig',
+});
+const updateServer = postTool({
+    name: 'dokploy_settings_update_server',
+    title: 'Update Server',
+    description: 'Update the Dokploy server to the latest available version. No parameters required. Returns the update status and new version information. This will restart the server process and may cause brief downtime.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.updateServer',
+});
+const getDokployVersion = getTool({
+    name: 'dokploy_settings_get_version',
+    title: 'Get Dokploy Version',
+    description: 'Get the currently running Dokploy server version. No parameters required. Returns the version string of the installed Dokploy instance. Useful for checking if updates are available.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getDokployVersion',
+});
+const readDirectories = getTool({
+    name: 'dokploy_settings_read_directories',
+    title: 'Read Server Directories',
+    description: 'Read the server directory listing to inspect the file system structure used by Dokploy. No parameters required. Returns a list of directories and their contents on the server where Dokploy stores its data and configurations.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.readDirectories',
+});
+const getOpenApiDocument = getTool({
+    name: 'dokploy_settings_get_openapi_document',
+    title: 'Get OpenAPI Document',
+    description: 'Get the Dokploy OpenAPI specification document describing all available API endpoints. No parameters required. Returns the full OpenAPI JSON document including paths, schemas, and authentication requirements.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getOpenApiDocument',
+});
+const readTraefikFile = getTool({
+    name: 'dokploy_settings_read_traefik_file',
+    title: 'Read Traefik File',
+    description: 'Read a specific Traefik configuration file from the server file system. Accepts a path parameter to specify which Traefik file to read. Returns the raw file content as a string. Useful for inspecting individual Traefik configuration files beyond the main config.',
+    schema: z
+        .object({
+        path: z.string().min(1).describe('Path to the Traefik configuration file to read'),
+    })
+        .strict(),
+    endpoint: '/settings.readTraefikFile',
+});
+const updateTraefikFile = postTool({
+    name: 'dokploy_settings_update_traefik_file',
+    title: 'Update Traefik File',
+    description: 'Update a specific Traefik configuration file on the server. Requires the file path and new content. Returns a confirmation. A Traefik reload may be needed to apply changes.',
+    schema: z
+        .object({
+        path: z.string().min(1).describe('Path to the Traefik configuration file to update'),
+        traefikConfig: z.string().min(1).describe('The new file content'),
+    })
+        .strict(),
+    endpoint: '/settings.updateTraefikFile',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const settingsTools = [
+    reloadServer,
+    reloadTraefik,
+    cleanUnusedImages,
+    cleanUnusedVolumes,
+    cleanStoppedContainers,
+    cleanDockerBuilder,
+    cleanDockerPrune,
+    cleanAll,
+    cleanMonitoring,
+    saveSSHPrivateKey,
+    cleanSSHPrivateKey,
+    assignDomainServer,
+    updateDockerCleanup,
+    readTraefikConfig,
+    updateTraefikConfig,
+    readWebServerTraefikConfig,
+    updateWebServerTraefikConfig,
+    readMiddlewareTraefikConfig,
+    updateMiddlewareTraefikConfig,
+    updateServer,
+    getDokployVersion,
+    readDirectories,
+    getOpenApiDocument,
+    readTraefikFile,
+    updateTraefikFile,
+];

package/dist/tools/user.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from './_factory.js';
+export declare const userTools: ToolDefinition[];

package/dist/tools/user.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { getTool } from './_factory.js';
+// ── tools ────────────────────────────────────────────────────────────
+const all = getTool({
+    name: 'dokploy_user_all',
+    title: 'List All Users',
+    description: 'List all users registered in the Dokploy instance. No parameters required. Returns an array of user objects including their IDs, emails, roles, and permission details.',
+    schema: z.object({}).strict(),
+    endpoint: '/user.all',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const userTools = [all];

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@vibetools/dokploy-mcp",
+  "version": "0.4.0",
+  "description": "MCP Server for the Dokploy API - complete coverage of all endpoints",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "dokploy-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "docs:api": "node scripts/openapi-to-markdown.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
+    "@types/node": "^22.19.11",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "sideEffects": false,
+  "license": "MIT",
+  "author": "Vibe Code <hello@vcode.sh>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vcode-sh/dokploy-mcp.git"
+  },
+  "homepage": "https://github.com/vcode-sh/dokploy-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/vcode-sh/dokploy-mcp/issues"
+  },
+  "keywords": [
+    "mcp",
+    "dokploy",
+    "model-context-protocol",
+    "devops",
+    "deployment",
+    "docker"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}