@vibetools/dokploy-mcp 1.0.0 → 1.2.0

package/dist/tools/patch.js

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const entityTypeSchema = z.enum(['application', 'compose']).describe('Entity type');
+const patchTypeSchema = z.enum(['create', 'update', 'delete']).describe('Patch type');
+const savePatchTypeSchema = z.enum(['create', 'update']).default('update').describe('Patch type');
+const nullableString = z.string().nullable().optional();
+const create = postTool({
+    name: 'dokploy_patch_create',
+    title: 'Create Patch',
+    description: 'Create a new patch record in Dokploy. Requires the file path and file content. Optionally associate the patch with an application or compose service.',
+    schema: z
+        .object({
+        filePath: z.string().min(1).describe('File path inside the repository'),
+        content: z.string().describe('File content'),
+        type: patchTypeSchema.optional(),
+        enabled: z.boolean().optional().describe('Whether the patch is enabled'),
+        applicationId: nullableString.describe('Application ID'),
+        composeId: nullableString.describe('Compose ID'),
+    })
+        .strict(),
+    endpoint: '/patch.create',
+});
+const one = getTool({
+    name: 'dokploy_patch_one',
+    title: 'Get Patch',
+    description: 'Retrieve a patch record by its ID.',
+    schema: z
+        .object({
+        patchId: z.string().min(1).describe('Patch ID'),
+    })
+        .strict(),
+    endpoint: '/patch.one',
+});
+const byEntityId = getTool({
+    name: 'dokploy_patch_by_entity_id',
+    title: 'List Patches by Entity',
+    description: 'List patches associated with a Dokploy application or compose service. Requires the entity ID and entity type.',
+    schema: z
+        .object({
+        id: z.string().describe('Entity ID'),
+        type: entityTypeSchema,
+    })
+        .strict(),
+    endpoint: '/patch.byEntityId',
+});
+const update = postTool({
+    name: 'dokploy_patch_update',
+    title: 'Update Patch',
+    description: 'Update an existing patch record in Dokploy. Requires the patch ID and optionally accepts updated type, file path, content, enablement state, and timestamps.',
+    schema: z
+        .object({
+        patchId: z.string().min(1).describe('Patch ID'),
+        type: patchTypeSchema.optional(),
+        filePath: z.string().min(1).optional().describe('File path inside the repository'),
+        enabled: z.boolean().optional().describe('Whether the patch is enabled'),
+        content: z.string().optional().describe('File content'),
+        createdAt: z.string().optional().describe('Creation timestamp'),
+        updatedAt: nullableString.describe('Update timestamp'),
+    })
+        .strict(),
+    endpoint: '/patch.update',
+});
+const remove = postTool({
+    name: 'dokploy_patch_delete',
+    title: 'Delete Patch',
+    description: 'Delete a patch record from Dokploy. Requires the patch ID. This is a destructive action.',
+    schema: z
+        .object({
+        patchId: z.string().min(1).describe('Patch ID'),
+    })
+        .strict(),
+    endpoint: '/patch.delete',
+    annotations: { destructiveHint: true },
+});
+const toggleEnabled = postTool({
+    name: 'dokploy_patch_toggle_enabled',
+    title: 'Toggle Patch',
+    description: 'Enable or disable a patch record in Dokploy. Requires the patch ID and the desired enabled state.',
+    schema: z
+        .object({
+        patchId: z.string().min(1).describe('Patch ID'),
+        enabled: z.boolean().describe('Whether the patch should be enabled'),
+    })
+        .strict(),
+    endpoint: '/patch.toggleEnabled',
+});
+const ensureRepo = postTool({
+    name: 'dokploy_patch_ensure_repo',
+    title: 'Ensure Patch Repository',
+    description: 'Ensure that the local patch repository exists for a Dokploy application or compose service. Requires the entity ID and entity type.',
+    schema: z
+        .object({
+        id: z.string().describe('Entity ID'),
+        type: entityTypeSchema,
+    })
+        .strict(),
+    endpoint: '/patch.ensureRepo',
+});
+const readRepoDirectories = getTool({
+    name: 'dokploy_patch_read_repo_directories',
+    title: 'Read Patch Repository Directories',
+    description: 'Read directory entries inside a patch repository. Requires the entity ID, entity type, and repository path.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        type: entityTypeSchema,
+        repoPath: z.string().describe('Repository path'),
+    })
+        .strict(),
+    endpoint: '/patch.readRepoDirectories',
+});
+const readRepoFile = getTool({
+    name: 'dokploy_patch_read_repo_file',
+    title: 'Read Patch Repository File',
+    description: 'Read a file from a patch repository. Requires the entity ID, entity type, and file path.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        type: entityTypeSchema,
+        filePath: z.string().describe('File path'),
+    })
+        .strict(),
+    endpoint: '/patch.readRepoFile',
+});
+const saveFileAsPatch = postTool({
+    name: 'dokploy_patch_save_file_as_patch',
+    title: 'Save File as Patch',
+    description: 'Create or update a patch record from file content. Requires the entity ID, entity type, file path, and content.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        type: entityTypeSchema,
+        filePath: z.string().describe('File path'),
+        content: z.string().describe('File content'),
+        patchType: savePatchTypeSchema.optional(),
+    })
+        .strict(),
+    endpoint: '/patch.saveFileAsPatch',
+});
+const markFileForDeletion = postTool({
+    name: 'dokploy_patch_mark_file_for_deletion',
+    title: 'Mark File for Deletion',
+    description: 'Mark a file for deletion through the Dokploy patch workflow. Requires the entity ID, entity type, and file path.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        type: entityTypeSchema,
+        filePath: z.string().describe('File path'),
+    })
+        .strict(),
+    endpoint: '/patch.markFileForDeletion',
+    annotations: { destructiveHint: true },
+});
+const cleanPatchRepos = postTool({
+    name: 'dokploy_patch_clean_patch_repos',
+    title: 'Clean Patch Repositories',
+    description: 'Clean Dokploy patch repositories. Optionally scope the cleanup to a specific server.',
+    schema: z
+        .object({
+        serverId: z.string().optional().describe('Optional server ID'),
+    })
+        .strict(),
+    endpoint: '/patch.cleanPatchRepos',
+    annotations: { destructiveHint: true },
+});
+export const patchTools = [
+    create,
+    one,
+    byEntityId,
+    update,
+    remove,
+    toggleEnabled,
+    ensureRepo,
+    readRepoDirectories,
+    readRepoFile,
+    saveFileAsPatch,
+    markFileForDeletion,
+    cleanPatchRepos,
+];

package/dist/tools/postgres.js

@@ -4,7 +4,7 @@ export const postgresTools = createDatabaseTools({
     type: 'postgres',
     idField: 'postgresId',
     displayName: 'Postgres',
-    defaultImage: 'postgres:15',
+    defaultImage: 'postgres:18',
     createFields: z.object({
         databaseName: z.string().min(1).describe('Name of the database to create'),
         databaseUser: z.string().min(1).describe('Database user'),

package/dist/tools/preview-deployment.d.ts

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

package/dist/tools/preview-deployment.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const all = getTool({
+    name: 'dokploy_preview_deployment_all',
+    title: 'List Preview Deployments',
+    description: 'List preview deployments for a Dokploy application. Requires the application ID.',
+    schema: z
+        .object({
+        applicationId: z.string().min(1).describe('Application ID'),
+    })
+        .strict(),
+    endpoint: '/previewDeployment.all',
+});
+const one = getTool({
+    name: 'dokploy_preview_deployment_one',
+    title: 'Get Preview Deployment',
+    description: 'Retrieve a preview deployment by its ID.',
+    schema: z
+        .object({
+        previewDeploymentId: z.string().describe('Preview deployment ID'),
+    })
+        .strict(),
+    endpoint: '/previewDeployment.one',
+});
+const remove = postTool({
+    name: 'dokploy_preview_deployment_delete',
+    title: 'Delete Preview Deployment',
+    description: 'Delete a preview deployment in Dokploy. Requires the preview deployment ID. This is a destructive action.',
+    schema: z
+        .object({
+        previewDeploymentId: z.string().describe('Preview deployment ID'),
+    })
+        .strict(),
+    endpoint: '/previewDeployment.delete',
+    annotations: { destructiveHint: true },
+});
+const redeploy = postTool({
+    name: 'dokploy_preview_deployment_redeploy',
+    title: 'Redeploy Preview Deployment',
+    description: 'Redeploy a preview deployment in Dokploy. Requires the preview deployment ID and optionally accepts a title and description.',
+    schema: z
+        .object({
+        previewDeploymentId: z.string().describe('Preview deployment ID'),
+        title: z.string().optional().describe('Optional deployment title'),
+        description: z.string().optional().describe('Optional deployment description'),
+    })
+        .strict(),
+    endpoint: '/previewDeployment.redeploy',
+});
+export const previewDeploymentTools = [all, one, remove, redeploy];

package/dist/tools/project.js

@@ -8,6 +8,13 @@ const all = getTool({
     schema: z.object({}).strict(),
     endpoint: '/project.all',
 });
+const allForPermissions = getTool({
+    name: 'dokploy_project_all_for_permissions',
+    title: 'List Projects for Permissions',
+    description: 'List projects in the format used by Dokploy permission assignment workflows.',
+    schema: z.object({}).strict(),
+    endpoint: '/project.allForPermissions',
+});
 const one = getTool({
     name: 'dokploy_project_one',
     title: 'Get Project Details',
@@ -90,5 +97,29 @@ const remove = postTool({
     endpoint: '/project.remove',
     annotations: { destructiveHint: true },
 });
+const search = getTool({
+    name: 'dokploy_project_search',
+    title: 'Search Projects',
+    description: 'Search Dokploy projects by free text or field-specific filters. Supports pagination through limit and offset.',
+    schema: z
+        .object({
+        q: z.string().optional().describe('Free-text query'),
+        name: z.string().optional().describe('Project name'),
+        description: z.string().optional().describe('Project description'),
+        limit: z.number().min(1).max(100).optional().describe('Maximum number of results'),
+        offset: z.number().min(0).optional().describe('Number of results to skip'),
+    })
+        .strict(),
+    endpoint: '/project.search',
+});
 // ── export ───────────────────────────────────────────────────────────
-export const projectTools = [all, one, create, update, duplicate, remove];
+export const projectTools = [
+    all,
+    allForPermissions,
+    one,
+    create,
+    update,
+    duplicate,
+    remove,
+    search,
+];

package/dist/tools/redis.js

@@ -4,7 +4,7 @@ export const redisTools = createDatabaseTools({
     type: 'redis',
     idField: 'redisId',
     displayName: 'Redis',
-    defaultImage: 'redis:7',
+    defaultImage: 'redis:8',
     createFields: z.object({
         databasePassword: z.string().min(1).describe('Database password'),
     }),

package/dist/tools/rollback.d.ts

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

package/dist/tools/rollback.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { postTool } from './_factory.js';
+const rollbackIdSchema = z.string().min(1).describe('Rollback ID');
+const rollback = postTool({
+    name: 'dokploy_rollback_rollback',
+    title: 'Execute Rollback',
+    description: 'Execute a rollback in Dokploy. Requires the rollback ID and triggers a rollback to the associated deployment target.',
+    schema: z
+        .object({
+        rollbackId: rollbackIdSchema,
+    })
+        .strict(),
+    endpoint: '/rollback.rollback',
+    annotations: { destructiveHint: true },
+});
+const remove = postTool({
+    name: 'dokploy_rollback_delete',
+    title: 'Delete Rollback Record',
+    description: 'Delete a rollback record from Dokploy. Requires the rollback ID. This is a destructive action.',
+    schema: z
+        .object({
+        rollbackId: rollbackIdSchema,
+    })
+        .strict(),
+    endpoint: '/rollback.delete',
+    annotations: { destructiveHint: true },
+});
+export const rollbackTools = [rollback, remove];

package/dist/tools/schedule.d.ts

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

package/dist/tools/schedule.js

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const nullableString = z.string().nullable().optional();
+const scheduleTypeSchema = z
+    .enum(['application', 'compose', 'server', 'dokploy-server'])
+    .describe('Schedule type');
+const shellTypeSchema = z.enum(['bash', 'sh']).describe('Shell type');
+const schedulePayload = z
+    .object({
+    scheduleId: z.string().optional().describe('Schedule ID'),
+    name: z.string().describe('Schedule name'),
+    cronExpression: z.string().describe('Cron expression'),
+    appName: z.string().optional().describe('App name'),
+    serviceName: nullableString.describe('Service name'),
+    shellType: shellTypeSchema.optional(),
+    scheduleType: scheduleTypeSchema.optional(),
+    command: z.string().describe('Command to execute'),
+    script: nullableString.describe('Inline script'),
+    applicationId: nullableString.describe('Application ID'),
+    composeId: nullableString.describe('Compose ID'),
+    serverId: nullableString.describe('Server ID'),
+    userId: nullableString.describe('User ID'),
+    enabled: z.boolean().optional().describe('Whether the schedule is enabled'),
+    timezone: nullableString.describe('Timezone'),
+    createdAt: z.string().optional().describe('Creation timestamp'),
+})
+    .strict();
+const list = getTool({
+    name: 'dokploy_schedule_list',
+    title: 'List Schedules',
+    description: 'List schedules in Dokploy for a specific entity ID and schedule type.',
+    schema: z
+        .object({
+        id: z.string().describe('Entity ID'),
+        scheduleType: scheduleTypeSchema,
+    })
+        .strict(),
+    endpoint: '/schedule.list',
+});
+const one = getTool({
+    name: 'dokploy_schedule_one',
+    title: 'Get Schedule',
+    description: 'Retrieve a Dokploy schedule by its ID.',
+    schema: z
+        .object({
+        scheduleId: z.string().describe('Schedule ID'),
+    })
+        .strict(),
+    endpoint: '/schedule.one',
+});
+const create = postTool({
+    name: 'dokploy_schedule_create',
+    title: 'Create Schedule',
+    description: 'Create a new schedule in Dokploy. Requires the schedule name, cron expression, and command.',
+    schema: schedulePayload,
+    endpoint: '/schedule.create',
+});
+const update = postTool({
+    name: 'dokploy_schedule_update',
+    title: 'Update Schedule',
+    description: 'Update an existing schedule in Dokploy. Requires the schedule ID together with the updated schedule payload.',
+    schema: schedulePayload
+        .extend({
+        scheduleId: z.string().min(1).describe('Schedule ID'),
+    })
+        .strict(),
+    endpoint: '/schedule.update',
+});
+const remove = postTool({
+    name: 'dokploy_schedule_delete',
+    title: 'Delete Schedule',
+    description: 'Delete a schedule from Dokploy. Requires the schedule ID. This is a destructive action.',
+    schema: z
+        .object({
+        scheduleId: z.string().describe('Schedule ID'),
+    })
+        .strict(),
+    endpoint: '/schedule.delete',
+    annotations: { destructiveHint: true },
+});
+const runManually = postTool({
+    name: 'dokploy_schedule_run_manually',
+    title: 'Run Schedule Manually',
+    description: 'Run a Dokploy schedule immediately. Requires the schedule ID.',
+    schema: z
+        .object({
+        scheduleId: z.string().min(1).describe('Schedule ID'),
+    })
+        .strict(),
+    endpoint: '/schedule.runManually',
+});
+export const scheduleTools = [list, one, create, update, remove, runManually];

package/dist/tools/server.d.ts

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

package/dist/tools/server.js

@@ -0,0 +1,192 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const serverIdSchema = z.string().min(1).describe('The server ID');
+const metricsConfigSchema = z
+    .object({
+    server: z
+        .object({
+        refreshRate: z.number().min(2).describe('Refresh rate in seconds'),
+        port: z.number().min(1).describe('Monitoring port'),
+        token: z.string().describe('Monitoring token'),
+        urlCallback: z.string().url().describe('Callback URL'),
+        retentionDays: z.number().min(1).describe('Retention period in days'),
+        cronJob: z.string().min(1).describe('Cron expression'),
+        thresholds: z
+            .object({
+            cpu: z.number().min(0).describe('CPU threshold'),
+            memory: z.number().min(0).describe('Memory threshold'),
+        })
+            .strict(),
+    })
+        .strict(),
+    containers: z
+        .object({
+        refreshRate: z.number().min(2).describe('Container refresh rate in seconds'),
+        services: z
+            .object({
+            include: z.array(z.string()).optional().describe('Services to include'),
+            exclude: z.array(z.string()).optional().describe('Services to exclude'),
+        })
+            .strict(),
+    })
+        .strict(),
+})
+    .strict();
+const serverPayload = z
+    .object({
+    name: z.string().min(1).describe('Server name'),
+    description: z.string().nullable().describe('Server description'),
+    ipAddress: z.string().describe('Server IP address'),
+    port: z.number().describe('SSH port'),
+    username: z.string().describe('SSH username'),
+    sshKeyId: z.string().nullable().describe('SSH key ID'),
+    serverType: z.enum(['deploy', 'build']).describe('Server role'),
+})
+    .strict();
+const all = getTool({
+    name: 'dokploy_server_all',
+    title: 'List Servers',
+    description: 'List all Dokploy servers available to the current account. Returns deploy and build servers with their metadata.',
+    schema: z.object({}).strict(),
+    endpoint: '/server.all',
+});
+const one = getTool({
+    name: 'dokploy_server_one',
+    title: 'Get Server',
+    description: 'Retrieve detailed information about a Dokploy server by its ID. Returns connection settings, monitoring state, and security details.',
+    schema: z.object({ serverId: serverIdSchema }).strict(),
+    endpoint: '/server.one',
+});
+const count = getTool({
+    name: 'dokploy_server_count',
+    title: 'Count Servers',
+    description: 'Return the number of servers configured in Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/server.count',
+});
+const withSshKey = getTool({
+    name: 'dokploy_server_with_ssh_key',
+    title: 'List Servers with SSH Keys',
+    description: 'List Dokploy servers together with their linked SSH key information. Useful when selecting a server-key pair for operations.',
+    schema: z.object({}).strict(),
+    endpoint: '/server.withSSHKey',
+});
+const buildServers = getTool({
+    name: 'dokploy_server_build_servers',
+    title: 'List Build Servers',
+    description: 'List Dokploy servers configured specifically for build workloads.',
+    schema: z.object({}).strict(),
+    endpoint: '/server.buildServers',
+});
+const validate = getTool({
+    name: 'dokploy_server_validate',
+    title: 'Validate Server',
+    description: 'Validate the SSH connectivity and server configuration for a Dokploy server. Requires the server ID.',
+    schema: z.object({ serverId: serverIdSchema }).strict(),
+    endpoint: '/server.validate',
+});
+const security = getTool({
+    name: 'dokploy_server_security',
+    title: 'Get Server Security',
+    description: 'Retrieve the server security posture and checks for a Dokploy server. Requires the server ID.',
+    schema: z.object({ serverId: serverIdSchema }).strict(),
+    endpoint: '/server.security',
+});
+const publicIp = getTool({
+    name: 'dokploy_server_public_ip',
+    title: 'Get Public IP',
+    description: 'Get the public IP address detected by Dokploy for the current installation.',
+    schema: z.object({}).strict(),
+    endpoint: '/server.publicIp',
+});
+const getServerTime = getTool({
+    name: 'dokploy_server_get_server_time',
+    title: 'Get Server Time',
+    description: 'Get the current server time reported by Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/server.getServerTime',
+});
+const getServerMetrics = getTool({
+    name: 'dokploy_server_get_server_metrics',
+    title: 'Get Server Metrics',
+    description: 'Retrieve server monitoring metrics from Dokploy. Requires the monitoring URL, token, and number of data points.',
+    schema: z
+        .object({
+        url: z.string().describe('Monitoring URL'),
+        token: z.string().describe('Monitoring token'),
+        dataPoints: z.string().describe('Number of data points'),
+    })
+        .strict(),
+    endpoint: '/server.getServerMetrics',
+});
+const getDefaultCommand = getTool({
+    name: 'dokploy_server_get_default_command',
+    title: 'Get Default Server Command',
+    description: 'Get the default provisioning command for a Dokploy server. Requires the server ID.',
+    schema: z.object({ serverId: serverIdSchema }).strict(),
+    endpoint: '/server.getDefaultCommand',
+});
+const create = postTool({
+    name: 'dokploy_server_create',
+    title: 'Create Server',
+    description: 'Create a new Dokploy server. Requires connection details, server type, and the linked SSH key ID or null for an unmanaged key.',
+    schema: serverPayload,
+    endpoint: '/server.create',
+});
+const update = postTool({
+    name: 'dokploy_server_update',
+    title: 'Update Server',
+    description: 'Update an existing Dokploy server. Requires the server ID together with the current server connection details and role. Optionally provide a command override.',
+    schema: serverPayload
+        .extend({
+        serverId: serverIdSchema,
+        command: z.string().optional().describe('Optional command override'),
+    })
+        .strict(),
+    endpoint: '/server.update',
+});
+const remove = postTool({
+    name: 'dokploy_server_remove',
+    title: 'Remove Server',
+    description: 'Permanently remove a Dokploy server from the installation. Requires the server ID. This operation is destructive.',
+    schema: z.object({ serverId: serverIdSchema }).strict(),
+    endpoint: '/server.remove',
+    annotations: { destructiveHint: true },
+});
+const setup = postTool({
+    name: 'dokploy_server_setup',
+    title: 'Setup Server',
+    description: 'Run the Dokploy setup workflow on an existing server. Requires the server ID.',
+    schema: z.object({ serverId: serverIdSchema }).strict(),
+    endpoint: '/server.setup',
+});
+const setupMonitoring = postTool({
+    name: 'dokploy_server_setup_monitoring',
+    title: 'Setup Server Monitoring',
+    description: 'Configure monitoring for a Dokploy server. Requires the server ID and a complete monitoring configuration.',
+    schema: z
+        .object({
+        serverId: serverIdSchema,
+        metricsConfig: metricsConfigSchema.describe('Monitoring configuration'),
+    })
+        .strict(),
+    endpoint: '/server.setupMonitoring',
+});
+export const serverTools = [
+    all,
+    one,
+    count,
+    withSshKey,
+    buildServers,
+    validate,
+    security,
+    publicIp,
+    getServerTime,
+    getServerMetrics,
+    getDefaultCommand,
+    create,
+    update,
+    remove,
+    setup,
+    setupMonitoring,
+];