@vibetools/dokploy-mcp 1.0.0 → 1.2.0

package/dist/tools/settings.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { getTool, postTool } from './_factory.js';
 // ── tools ────────────────────────────────────────────────────────────
+const optionalServerId = z.string().optional().describe('Optional server ID');
+const protocolSchema = z.enum(['tcp', 'udp', 'sctp']).describe('Port protocol');
 const reloadServer = postTool({
     name: 'dokploy_settings_reload_server',
     title: 'Reload Server',
@@ -228,6 +230,231 @@ const updateTraefikFile = postTool({
         .strict(),
     endpoint: '/settings.updateTraefikFile',
 });
+const readTraefikEnv = getTool({
+    name: 'dokploy_settings_read_traefik_env',
+    title: 'Read Traefik Environment',
+    description: 'Read the Traefik environment configuration from Dokploy. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.readTraefikEnv',
+});
+const writeTraefikEnv = postTool({
+    name: 'dokploy_settings_write_traefik_env',
+    title: 'Write Traefik Environment',
+    description: 'Write the Traefik environment configuration in Dokploy. Requires the environment content and optionally accepts a server ID.',
+    schema: z
+        .object({
+        env: z.string().describe('Traefik environment content'),
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.writeTraefikEnv',
+});
+const updateTraefikPorts = postTool({
+    name: 'dokploy_settings_update_traefik_ports',
+    title: 'Update Traefik Ports',
+    description: 'Update additional Traefik ports in Dokploy. Requires the list of additional ports and optionally accepts a server ID.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+        additionalPorts: z
+            .array(z
+            .object({
+            targetPort: z.number().describe('Target port'),
+            publishedPort: z.number().describe('Published port'),
+            protocol: protocolSchema,
+        })
+            .strict())
+            .describe('Additional Traefik ports'),
+    })
+        .strict(),
+    endpoint: '/settings.updateTraefikPorts',
+});
+const getTraefikPorts = getTool({
+    name: 'dokploy_settings_get_traefik_ports',
+    title: 'Get Traefik Ports',
+    description: 'Get Traefik ports configured in Dokploy. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.getTraefikPorts',
+});
+const haveTraefikDashboardPortEnabled = getTool({
+    name: 'dokploy_settings_have_traefik_dashboard_port_enabled',
+    title: 'Check Traefik Dashboard Port',
+    description: 'Check whether the Traefik dashboard port is enabled in Dokploy. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.haveTraefikDashboardPortEnabled',
+});
+const toggleDashboard = postTool({
+    name: 'dokploy_settings_toggle_dashboard',
+    title: 'Toggle Traefik Dashboard',
+    description: 'Enable or disable the Traefik dashboard in Dokploy. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        enableDashboard: z.boolean().optional().describe('Whether to enable the dashboard'),
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.toggleDashboard',
+});
+const health = getTool({
+    name: 'dokploy_settings_health',
+    title: 'Get Dokploy Health',
+    description: 'Get the current health status of the Dokploy installation.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.health',
+});
+const getIp = getTool({
+    name: 'dokploy_settings_get_ip',
+    title: 'Get Server IP',
+    description: 'Get the server IP address known to Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getIp',
+});
+const updateServerIp = postTool({
+    name: 'dokploy_settings_update_server_ip',
+    title: 'Update Server IP',
+    description: 'Update the server IP address used by Dokploy.',
+    schema: z
+        .object({
+        serverIp: z.string().describe('Server IP address'),
+    })
+        .strict(),
+    endpoint: '/settings.updateServerIp',
+});
+const getWebServerSettings = getTool({
+    name: 'dokploy_settings_get_web_server_settings',
+    title: 'Get Web Server Settings',
+    description: 'Get web server settings configured in Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getWebServerSettings',
+});
+const getUpdateData = postTool({
+    name: 'dokploy_settings_get_update_data',
+    title: 'Get Update Data',
+    description: 'Get update metadata for the current Dokploy installation.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getUpdateData',
+});
+const getReleaseTag = getTool({
+    name: 'dokploy_settings_get_release_tag',
+    title: 'Get Release Tag',
+    description: 'Get the latest Dokploy release tag visible to the current installation.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getReleaseTag',
+});
+const cleanRedis = postTool({
+    name: 'dokploy_settings_clean_redis',
+    title: 'Clean Redis',
+    description: 'Clean Dokploy Redis data. This is a destructive maintenance action.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanRedis',
+    annotations: { destructiveHint: true },
+});
+const reloadRedis = postTool({
+    name: 'dokploy_settings_reload_redis',
+    title: 'Reload Redis',
+    description: 'Reload Dokploy Redis.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.reloadRedis',
+});
+const cleanAllDeploymentQueue = postTool({
+    name: 'dokploy_settings_clean_all_deployment_queue',
+    title: 'Clean Deployment Queue',
+    description: 'Clear the Dokploy deployment queue. This is a destructive maintenance action.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanAllDeploymentQueue',
+    annotations: { destructiveHint: true },
+});
+const updateLogCleanup = postTool({
+    name: 'dokploy_settings_update_log_cleanup',
+    title: 'Update Log Cleanup Schedule',
+    description: 'Update the Dokploy log cleanup schedule.',
+    schema: z
+        .object({
+        cronExpression: z.string().nullable().describe('Cron expression for log cleanup'),
+    })
+        .strict(),
+    endpoint: '/settings.updateLogCleanup',
+});
+const getLogCleanupStatus = getTool({
+    name: 'dokploy_settings_get_log_cleanup_status',
+    title: 'Get Log Cleanup Status',
+    description: 'Get the current Dokploy log cleanup configuration and status.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getLogCleanupStatus',
+});
+const setupGpu = postTool({
+    name: 'dokploy_settings_setup_gpu',
+    title: 'Setup GPU',
+    description: 'Run Dokploy GPU setup. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.setupGPU',
+});
+const checkGpuStatus = getTool({
+    name: 'dokploy_settings_check_gpu_status',
+    title: 'Check GPU Status',
+    description: 'Check Dokploy GPU status. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.checkGPUStatus',
+});
+const isCloud = getTool({
+    name: 'dokploy_settings_is_cloud',
+    title: 'Check Cloud Mode',
+    description: 'Check whether the current Dokploy installation runs in cloud mode.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.isCloud',
+});
+const isUserSubscribed = getTool({
+    name: 'dokploy_settings_is_user_subscribed',
+    title: 'Check Subscription Status',
+    description: 'Check whether the current Dokploy user has an active subscription.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.isUserSubscribed',
+});
+const haveActivateRequests = getTool({
+    name: 'dokploy_settings_have_activate_requests',
+    title: 'Check Request Logging',
+    description: 'Check whether request handling features are enabled in Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.haveActivateRequests',
+});
+const toggleRequests = postTool({
+    name: 'dokploy_settings_toggle_requests',
+    title: 'Toggle Requests',
+    description: 'Enable or disable request handling features in Dokploy.',
+    schema: z
+        .object({
+        enable: z.boolean().describe('Whether to enable requests'),
+    })
+        .strict(),
+    endpoint: '/settings.toggleRequests',
+});
+const getDokployCloudIps = getTool({
+    name: 'dokploy_settings_get_dokploy_cloud_ips',
+    title: 'Get Dokploy Cloud IPs',
+    description: 'Get Dokploy Cloud IP ranges.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getDokployCloudIps',
+});
 // ── export ───────────────────────────────────────────────────────────
 export const settingsTools = [
     reloadServer,
@@ -255,4 +482,28 @@ export const settingsTools = [
     getOpenApiDocument,
     readTraefikFile,
     updateTraefikFile,
+    readTraefikEnv,
+    writeTraefikEnv,
+    updateTraefikPorts,
+    getTraefikPorts,
+    haveTraefikDashboardPortEnabled,
+    toggleDashboard,
+    health,
+    getIp,
+    updateServerIp,
+    getWebServerSettings,
+    getUpdateData,
+    getReleaseTag,
+    cleanRedis,
+    reloadRedis,
+    cleanAllDeploymentQueue,
+    updateLogCleanup,
+    getLogCleanupStatus,
+    setupGpu,
+    checkGpuStatus,
+    isCloud,
+    isUserSubscribed,
+    haveActivateRequests,
+    toggleRequests,
+    getDokployCloudIps,
 ];

package/dist/tools/ssh-key.d.ts

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

package/dist/tools/ssh-key.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const nullableString = z.string().nullable().optional();
+const all = getTool({
+    name: 'dokploy_ssh_key_all',
+    title: 'List SSH Keys',
+    description: 'List all SSH keys available in Dokploy. Returns stored keys together with their metadata and organization context.',
+    schema: z.object({}).strict(),
+    endpoint: '/sshKey.all',
+});
+const create = postTool({
+    name: 'dokploy_ssh_key_create',
+    title: 'Create SSH Key',
+    description: 'Create a new SSH key record in Dokploy. Requires the key pair and a name. Optionally set a description and organization ID.',
+    schema: z
+        .object({
+        name: z.string().min(1).describe('SSH key name'),
+        description: z.string().nullable().optional().describe('SSH key description'),
+        privateKey: z.string().describe('Private key content'),
+        publicKey: z.string().describe('Public key content'),
+        organizationId: z.string().optional().describe('Organization ID'),
+    })
+        .strict(),
+    endpoint: '/sshKey.create',
+});
+const generate = postTool({
+    name: 'dokploy_ssh_key_generate',
+    title: 'Generate SSH Key Pair',
+    description: 'Generate a new SSH key pair in Dokploy. Optionally specify the key type; supported values are rsa and ed25519.',
+    schema: z
+        .object({
+        type: z.enum(['rsa', 'ed25519']).optional().describe('SSH key type'),
+    })
+        .strict(),
+    endpoint: '/sshKey.generate',
+});
+const one = getTool({
+    name: 'dokploy_ssh_key_one',
+    title: 'Get SSH Key',
+    description: 'Retrieve detailed information about a Dokploy SSH key by its ID.',
+    schema: z
+        .object({
+        sshKeyId: z.string().min(1).describe('SSH key ID'),
+    })
+        .strict(),
+    endpoint: '/sshKey.one',
+});
+const remove = postTool({
+    name: 'dokploy_ssh_key_remove',
+    title: 'Remove SSH Key',
+    description: 'Permanently remove an SSH key from Dokploy. Requires the SSH key ID. This is a destructive action.',
+    schema: z
+        .object({
+        sshKeyId: z.string().min(1).describe('SSH key ID'),
+    })
+        .strict(),
+    endpoint: '/sshKey.remove',
+    annotations: { destructiveHint: true },
+});
+const update = postTool({
+    name: 'dokploy_ssh_key_update',
+    title: 'Update SSH Key',
+    description: 'Update metadata for a Dokploy SSH key. Requires the SSH key ID and accepts optional name, description, and last-used timestamp changes.',
+    schema: z
+        .object({
+        sshKeyId: z.string().min(1).describe('SSH key ID'),
+        name: z.string().min(1).optional().describe('SSH key name'),
+        description: nullableString.describe('SSH key description'),
+        lastUsedAt: nullableString.describe('Last used timestamp'),
+    })
+        .strict(),
+    endpoint: '/sshKey.update',
+});
+export const sshKeyTools = [all, create, generate, one, remove, update];

package/dist/tools/user.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { getTool } from './_factory.js';
+import { getTool, postTool } from './_factory.js';
 // ── tools ────────────────────────────────────────────────────────────
 const all = getTool({
     name: 'dokploy_user_all',
@@ -8,5 +8,78 @@ const all = getTool({
     schema: z.object({}).strict(),
     endpoint: '/user.all',
 });
+const session = getTool({
+    name: 'dokploy_user_session',
+    title: 'Get User Session',
+    description: 'Get the current authenticated user session from Dokploy, including session and identity metadata.',
+    schema: z.object({}).strict(),
+    endpoint: '/user.session',
+});
+const get = getTool({
+    name: 'dokploy_user_get',
+    title: 'Get Current User',
+    description: 'Get the current authenticated Dokploy user profile.',
+    schema: z.object({}).strict(),
+    endpoint: '/user.get',
+});
+const getPermissions = getTool({
+    name: 'dokploy_user_get_permissions',
+    title: 'Get Current User Permissions',
+    description: 'Get the current authenticated Dokploy user permissions.',
+    schema: z.object({}).strict(),
+    endpoint: '/user.getPermissions',
+});
+const haveRootAccess = getTool({
+    name: 'dokploy_user_have_root_access',
+    title: 'Check Root Access',
+    description: 'Check whether the current authenticated Dokploy user has root access.',
+    schema: z.object({}).strict(),
+    endpoint: '/user.haveRootAccess',
+});
+const createApiKey = postTool({
+    name: 'dokploy_user_create_api_key',
+    title: 'Create API Key',
+    description: 'Create a new Dokploy API key. Requires a name and organization metadata. Optionally configure expiration and rate limiting.',
+    schema: z
+        .object({
+        name: z.string().min(1).describe('API key name'),
+        prefix: z.string().optional().describe('API key prefix'),
+        expiresIn: z.number().optional().describe('Expiration interval'),
+        metadata: z
+            .object({
+            organizationId: z.string().describe('Organization ID'),
+        })
+            .strict()
+            .describe('API key metadata'),
+        rateLimitEnabled: z.boolean().optional().describe('Whether rate limiting is enabled'),
+        rateLimitTimeWindow: z.number().optional().describe('Rate limit time window'),
+        rateLimitMax: z.number().optional().describe('Rate limit max requests'),
+        remaining: z.number().optional().describe('Remaining requests'),
+        refillAmount: z.number().optional().describe('Rate limit refill amount'),
+        refillInterval: z.number().optional().describe('Rate limit refill interval'),
+    })
+        .strict(),
+    endpoint: '/user.createApiKey',
+});
+const deleteApiKey = postTool({
+    name: 'dokploy_user_delete_api_key',
+    title: 'Delete API Key',
+    description: 'Delete a Dokploy API key by its ID. This is a destructive action.',
+    schema: z
+        .object({
+        apiKeyId: z.string().describe('API key ID'),
+    })
+        .strict(),
+    endpoint: '/user.deleteApiKey',
+    annotations: { destructiveHint: true },
+});
 // ── export ───────────────────────────────────────────────────────────
-export const userTools = [all];
+export const userTools = [
+    all,
+    session,
+    get,
+    getPermissions,
+    haveRootAccess,
+    createApiKey,
+    deleteApiKey,
+];

package/dist/tools/volume-backups.d.ts

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

package/dist/tools/volume-backups.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const serviceTypeSchema = z
+    .enum(['application', 'postgres', 'mysql', 'mariadb', 'mongo', 'redis', 'compose'])
+    .describe('Service type');
+const nullableString = z.string().nullable().optional();
+const nullableBoolean = z.boolean().nullable().optional();
+const nullableNumber = z.number().nullable().optional();
+const volumeBackupPayload = z
+    .object({
+    name: z.string().describe('Volume backup name'),
+    volumeName: z.string().describe('Docker volume name'),
+    prefix: z.string().describe('Backup file prefix'),
+    serviceType: serviceTypeSchema.optional(),
+    appName: z.string().optional().describe('App name'),
+    serviceName: nullableString.describe('Compose service name'),
+    turnOff: z.boolean().optional().describe('Whether to turn off the service during backup'),
+    cronExpression: z.string().describe('Cron expression'),
+    keepLatestCount: nullableNumber.describe('Number of backups to keep'),
+    enabled: nullableBoolean.describe('Whether the backup is enabled'),
+    applicationId: nullableString.describe('Application ID'),
+    postgresId: nullableString.describe('Postgres ID'),
+    mariadbId: nullableString.describe('MariaDB ID'),
+    mongoId: nullableString.describe('MongoDB ID'),
+    mysqlId: nullableString.describe('MySQL ID'),
+    redisId: nullableString.describe('Redis ID'),
+    composeId: nullableString.describe('Compose ID'),
+    createdAt: z.string().optional().describe('Creation timestamp'),
+    destinationId: z.string().describe('Destination ID'),
+})
+    .strict();
+const list = getTool({
+    name: 'dokploy_volume_backups_list',
+    title: 'List Volume Backups',
+    description: 'List volume backup configurations for a Dokploy service type. Requires the entity ID and volume backup type.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        volumeBackupType: serviceTypeSchema.describe('Volume backup type'),
+    })
+        .strict(),
+    endpoint: '/volumeBackups.list',
+});
+const one = getTool({
+    name: 'dokploy_volume_backups_one',
+    title: 'Get Volume Backup',
+    description: 'Retrieve a volume backup configuration by its ID.',
+    schema: z
+        .object({
+        volumeBackupId: z.string().min(1).describe('Volume backup ID'),
+    })
+        .strict(),
+    endpoint: '/volumeBackups.one',
+});
+const create = postTool({
+    name: 'dokploy_volume_backups_create',
+    title: 'Create Volume Backup',
+    description: 'Create a volume backup configuration in Dokploy. Requires the backup name, volume name, prefix, cron expression, and destination ID.',
+    schema: volumeBackupPayload,
+    endpoint: '/volumeBackups.create',
+});
+const update = postTool({
+    name: 'dokploy_volume_backups_update',
+    title: 'Update Volume Backup',
+    description: 'Update a volume backup configuration in Dokploy. Requires the volume backup ID together with the updated backup payload.',
+    schema: volumeBackupPayload
+        .extend({
+        volumeBackupId: z.string().min(1).describe('Volume backup ID'),
+    })
+        .strict(),
+    endpoint: '/volumeBackups.update',
+});
+const remove = postTool({
+    name: 'dokploy_volume_backups_delete',
+    title: 'Delete Volume Backup',
+    description: 'Delete a volume backup configuration from Dokploy. Requires the volume backup ID. This is a destructive action.',
+    schema: z
+        .object({
+        volumeBackupId: z.string().min(1).describe('Volume backup ID'),
+    })
+        .strict(),
+    endpoint: '/volumeBackups.delete',
+    annotations: { destructiveHint: true },
+});
+const runManually = postTool({
+    name: 'dokploy_volume_backups_run_manually',
+    title: 'Run Volume Backup Manually',
+    description: 'Trigger a volume backup immediately in Dokploy. Requires the volume backup ID.',
+    schema: z
+        .object({
+        volumeBackupId: z.string().min(1).describe('Volume backup ID'),
+    })
+        .strict(),
+    endpoint: '/volumeBackups.runManually',
+});
+export const volumeBackupsTools = [list, one, create, update, remove, runManually];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibetools/dokploy-mcp",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "MCP Server for the Dokploy API - complete coverage of all endpoints",
   "type": "module",
   "exports": {