@vibetools/dokploy-mcp 1.0.0 → 1.2.0

package/dist/tools/environment.js

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const paginationLimit = z.number().min(1).max(100).optional().describe('Maximum number of results');
+const paginationOffset = z.number().min(0).optional().describe('Number of results to skip');
+const create = postTool({
+    name: 'dokploy_environment_create',
+    title: 'Create Environment',
+    description: 'Create a new environment inside a Dokploy project. Requires the project ID and environment name. Optionally set a description. Returns the created environment object.',
+    schema: z
+        .object({
+        name: z.string().min(1).describe('The environment name'),
+        description: z.string().optional().describe('Environment description'),
+        projectId: z.string().min(1).describe('The project ID'),
+    })
+        .strict(),
+    endpoint: '/environment.create',
+});
+const one = getTool({
+    name: 'dokploy_environment_one',
+    title: 'Get Environment',
+    description: 'Retrieve detailed information about a Dokploy environment by its ID. Returns the environment, services, and related project metadata.',
+    schema: z
+        .object({
+        environmentId: z.string().min(1).describe('The environment ID'),
+    })
+        .strict(),
+    endpoint: '/environment.one',
+});
+const byProjectId = getTool({
+    name: 'dokploy_environment_by_project_id',
+    title: 'List Environments by Project',
+    description: 'List all environments belonging to a Dokploy project. Requires the project ID. Returns the environments configured for that project.',
+    schema: z
+        .object({
+        projectId: z.string().min(1).describe('The project ID'),
+    })
+        .strict(),
+    endpoint: '/environment.byProjectId',
+});
+const remove = postTool({
+    name: 'dokploy_environment_remove',
+    title: 'Remove Environment',
+    description: 'Permanently remove a Dokploy environment. This action is destructive and may remove all services that belong to the environment. Requires the environment ID.',
+    schema: z
+        .object({
+        environmentId: z.string().min(1).describe('The environment ID'),
+    })
+        .strict(),
+    endpoint: '/environment.remove',
+    annotations: { destructiveHint: true },
+});
+const update = postTool({
+    name: 'dokploy_environment_update',
+    title: 'Update Environment',
+    description: 'Update an existing Dokploy environment. Requires the environment ID and accepts optional changes to the environment name, description, project assignment, and environment variables.',
+    schema: z
+        .object({
+        environmentId: z.string().min(1).describe('The environment ID'),
+        name: z.string().min(1).optional().describe('Environment name'),
+        description: z.string().optional().describe('Environment description'),
+        projectId: z.string().optional().describe('Project ID'),
+        env: z.string().optional().describe('Environment variables'),
+    })
+        .strict(),
+    endpoint: '/environment.update',
+});
+const duplicate = postTool({
+    name: 'dokploy_environment_duplicate',
+    title: 'Duplicate Environment',
+    description: 'Duplicate an existing Dokploy environment. Requires the source environment ID and a name for the new environment. Optionally set a description.',
+    schema: z
+        .object({
+        environmentId: z.string().min(1).describe('The source environment ID'),
+        name: z.string().min(1).describe('The new environment name'),
+        description: z.string().optional().describe('New environment description'),
+    })
+        .strict(),
+    endpoint: '/environment.duplicate',
+});
+const search = getTool({
+    name: 'dokploy_environment_search',
+    title: 'Search Environments',
+    description: 'Search Dokploy environments 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('Environment name'),
+        description: z.string().optional().describe('Environment description'),
+        projectId: z.string().optional().describe('Project ID'),
+        limit: paginationLimit,
+        offset: paginationOffset,
+    })
+        .strict(),
+    endpoint: '/environment.search',
+});
+export const environmentTools = [
+    create,
+    one,
+    byProjectId,
+    remove,
+    update,
+    duplicate,
+    search,
+];

package/dist/tools/git-provider.d.ts

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

package/dist/tools/git-provider.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const getAll = getTool({
+    name: 'dokploy_git_provider_get_all',
+    title: 'List Git Providers',
+    description: 'List all Git provider integrations available in Dokploy, including provider metadata and linked platform records.',
+    schema: z.object({}).strict(),
+    endpoint: '/gitProvider.getAll',
+});
+const remove = postTool({
+    name: 'dokploy_git_provider_remove',
+    title: 'Remove Git Provider',
+    description: 'Remove a Git provider integration from Dokploy. Requires the Git provider ID. This is a destructive action.',
+    schema: z
+        .object({
+        gitProviderId: z.string().min(1).describe('Git provider ID'),
+    })
+        .strict(),
+    endpoint: '/gitProvider.remove',
+    annotations: { destructiveHint: true },
+});
+export const gitProviderTools = [getAll, remove];

package/dist/tools/github.d.ts

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

package/dist/tools/github.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const githubIdSchema = z.string().min(1).describe('GitHub provider ID');
+const one = getTool({
+    name: 'dokploy_github_one',
+    title: 'Get GitHub Provider',
+    description: 'Retrieve a GitHub provider integration by its ID.',
+    schema: z.object({ githubId: githubIdSchema }).strict(),
+    endpoint: '/github.one',
+});
+const getGithubRepositories = getTool({
+    name: 'dokploy_github_get_github_repositories',
+    title: 'List GitHub Repositories',
+    description: 'List GitHub repositories available through a Dokploy GitHub provider integration. Requires the GitHub provider ID.',
+    schema: z.object({ githubId: githubIdSchema }).strict(),
+    endpoint: '/github.getGithubRepositories',
+});
+const getGithubBranches = getTool({
+    name: 'dokploy_github_get_github_branches',
+    title: 'List GitHub Branches',
+    description: 'List branches for a GitHub repository through Dokploy. Requires the repository name and owner. Optionally pass the GitHub provider ID.',
+    schema: z
+        .object({
+        repo: z.string().min(1).describe('Repository name'),
+        owner: z.string().min(1).describe('Repository owner'),
+        githubId: z.string().optional().describe('GitHub provider ID'),
+    })
+        .strict(),
+    endpoint: '/github.getGithubBranches',
+});
+const githubProviders = getTool({
+    name: 'dokploy_github_github_providers',
+    title: 'List GitHub Providers',
+    description: 'List GitHub provider integrations configured in Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/github.githubProviders',
+});
+const testConnection = postTool({
+    name: 'dokploy_github_test_connection',
+    title: 'Test GitHub Connection',
+    description: 'Test a Dokploy GitHub provider connection by its ID.',
+    schema: z.object({ githubId: githubIdSchema }).strict(),
+    endpoint: '/github.testConnection',
+});
+const update = postTool({
+    name: 'dokploy_github_update',
+    title: 'Update GitHub Provider',
+    description: 'Update a Dokploy GitHub provider integration. Requires the provider ID, display name, linked Git provider ID, and GitHub App name.',
+    schema: z
+        .object({
+        githubId: githubIdSchema,
+        name: z.string().min(1).describe('Provider display name'),
+        gitProviderId: z.string().min(1).describe('Git provider ID'),
+        githubAppName: z.string().min(1).describe('GitHub App name'),
+    })
+        .strict(),
+    endpoint: '/github.update',
+});
+export const githubTools = [
+    one,
+    getGithubRepositories,
+    getGithubBranches,
+    githubProviders,
+    testConnection,
+    update,
+];

package/dist/tools/gitlab.d.ts

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

package/dist/tools/gitlab.js

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const nullableString = z.string().nullable().optional();
+const gitlabIdSchema = z.string().min(1).describe('GitLab provider ID');
+const create = postTool({
+    name: 'dokploy_gitlab_create',
+    title: 'Create GitLab Provider',
+    description: 'Create a new GitLab provider integration in Dokploy. Requires the auth ID, name, and GitLab URL. Additional OAuth and provider fields may also be supplied.',
+    schema: z
+        .object({
+        applicationId: z.string().optional().describe('Application ID'),
+        secret: z.string().optional().describe('OAuth client secret'),
+        groupName: z.string().optional().describe('GitLab group name'),
+        gitProviderId: z.string().optional().describe('Git provider ID'),
+        redirectUri: z.string().optional().describe('OAuth redirect URI'),
+        authId: z.string().min(1).describe('Auth ID'),
+        name: z.string().min(1).describe('Provider display name'),
+        gitlabUrl: z.string().min(1).describe('GitLab URL'),
+        gitlabInternalUrl: nullableString.describe('Internal GitLab URL'),
+    })
+        .strict(),
+    endpoint: '/gitlab.create',
+});
+const one = getTool({
+    name: 'dokploy_gitlab_one',
+    title: 'Get GitLab Provider',
+    description: 'Retrieve a GitLab provider integration by its ID.',
+    schema: z.object({ gitlabId: gitlabIdSchema }).strict(),
+    endpoint: '/gitlab.one',
+});
+const getGitlabRepositories = getTool({
+    name: 'dokploy_gitlab_get_gitlab_repositories',
+    title: 'List GitLab Repositories',
+    description: 'List repositories available through a Dokploy GitLab provider integration. Requires the GitLab provider ID.',
+    schema: z.object({ gitlabId: gitlabIdSchema }).strict(),
+    endpoint: '/gitlab.getGitlabRepositories',
+});
+const getGitlabBranches = getTool({
+    name: 'dokploy_gitlab_get_gitlab_branches',
+    title: 'List GitLab Branches',
+    description: 'List branches for a GitLab repository through Dokploy. Requires the owner and repository. Optionally pass the project numeric ID and GitLab provider ID.',
+    schema: z
+        .object({
+        id: z.number().optional().describe('GitLab project numeric ID'),
+        owner: z.string().describe('Repository owner'),
+        repo: z.string().describe('Repository name'),
+        gitlabId: z.string().optional().describe('GitLab provider ID'),
+    })
+        .strict(),
+    endpoint: '/gitlab.getGitlabBranches',
+});
+const gitlabProviders = getTool({
+    name: 'dokploy_gitlab_gitlab_providers',
+    title: 'List GitLab Providers',
+    description: 'List GitLab provider integrations configured in Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/gitlab.gitlabProviders',
+});
+const testConnection = postTool({
+    name: 'dokploy_gitlab_test_connection',
+    title: 'Test GitLab Connection',
+    description: 'Test a Dokploy GitLab provider integration. Requires the GitLab provider ID and optionally accepts the group name.',
+    schema: z
+        .object({
+        gitlabId: gitlabIdSchema,
+        groupName: z.string().optional().describe('GitLab group name'),
+    })
+        .strict(),
+    endpoint: '/gitlab.testConnection',
+});
+const update = postTool({
+    name: 'dokploy_gitlab_update',
+    title: 'Update GitLab Provider',
+    description: 'Update a Dokploy GitLab provider integration. Requires the GitLab provider ID, display name, GitLab URL, and linked Git provider ID. Optional OAuth and group fields may also be supplied.',
+    schema: z
+        .object({
+        applicationId: z.string().optional().describe('Application ID'),
+        secret: z.string().optional().describe('OAuth client secret'),
+        groupName: z.string().optional().describe('GitLab group name'),
+        redirectUri: z.string().optional().describe('OAuth redirect URI'),
+        name: z.string().min(1).describe('Provider display name'),
+        gitlabId: gitlabIdSchema,
+        gitlabUrl: z.string().min(1).describe('GitLab URL'),
+        gitProviderId: z.string().min(1).describe('Git provider ID'),
+        gitlabInternalUrl: nullableString.describe('Internal GitLab URL'),
+    })
+        .strict(),
+    endpoint: '/gitlab.update',
+});
+export const gitlabTools = [
+    create,
+    one,
+    getGitlabRepositories,
+    getGitlabBranches,
+    gitlabProviders,
+    testConnection,
+    update,
+];

package/dist/tools/index.js

@@ -8,29 +8,48 @@ import { deploymentTools } from './deployment.js';
 import { destinationTools } from './destination.js';
 import { dockerTools } from './docker.js';
 import { domainTools } from './domain.js';
+import { environmentTools } from './environment.js';
+import { gitProviderTools } from './git-provider.js';
+import { githubTools } from './github.js';
+import { gitlabTools } from './gitlab.js';
 import { mariadbTools } from './mariadb.js';
 import { mongoTools } from './mongo.js';
 import { mountsTools } from './mounts.js';
 import { mysqlTools } from './mysql.js';
+import { notificationTools } from './notification.js';
+import { patchTools } from './patch.js';
 import { portTools } from './port.js';
 import { postgresTools } from './postgres.js';
+import { previewDeploymentTools } from './preview-deployment.js';
 import { projectTools } from './project.js';
 import { redirectsTools } from './redirects.js';
 import { redisTools } from './redis.js';
 import { registryTools } from './registry.js';
+import { rollbackTools } from './rollback.js';
+import { scheduleTools } from './schedule.js';
 import { securityTools } from './security.js';
+import { serverTools } from './server.js';
 import { settingsTools } from './settings.js';
+import { sshKeyTools } from './ssh-key.js';
 import { userTools } from './user.js';
+import { volumeBackupsTools } from './volume-backups.js';
 export const allTools = [
     ...projectTools,
+    ...environmentTools,
     ...applicationTools,
     ...composeTools,
     ...domainTools,
+    ...patchTools,
     ...postgresTools,
+    ...previewDeploymentTools,
     ...mysqlTools,
     ...mariadbTools,
     ...mongoTools,
     ...redisTools,
+    ...notificationTools,
+    ...rollbackTools,
+    ...scheduleTools,
+    ...volumeBackupsTools,
     ...deploymentTools,
     ...dockerTools,
     ...certificatesTools,
@@ -45,4 +64,9 @@ export const allTools = [
     ...settingsTools,
     ...adminTools,
     ...userTools,
+    ...serverTools,
+    ...sshKeyTools,
+    ...gitProviderTools,
+    ...githubTools,
+    ...gitlabTools,
 ];

package/dist/tools/mariadb.js

@@ -9,6 +9,6 @@ export const mariadbTools = createDatabaseTools({
         databaseName: z.string().min(1).describe('Name of the database to create'),
         databaseUser: z.string().min(1).describe('Database user'),
         databasePassword: z.string().min(1).describe('Database password'),
-        databaseRootPassword: z.string().min(1).describe('Root password for MariaDB'),
+        databaseRootPassword: z.string().min(1).optional().describe('Root password for MariaDB'),
     }),
 });

package/dist/tools/mongo.js

@@ -4,9 +4,10 @@ export const mongoTools = createDatabaseTools({
     type: 'mongo',
     idField: 'mongoId',
     displayName: 'MongoDB',
-    defaultImage: 'mongo:6',
+    defaultImage: 'mongo:15',
     createFields: z.object({
         databaseUser: z.string().min(1).describe('Database user'),
         databasePassword: z.string().min(1).describe('Database password'),
+        replicaSets: z.boolean().nullable().optional().describe('Whether replica sets are enabled'),
     }),
 });

package/dist/tools/mounts.js

@@ -13,6 +13,17 @@ const one = getTool({
     schema: z.object({ mountId }).strict(),
     endpoint: '/mounts.one',
 });
+const allNamedByApplicationId = getTool({
+    name: 'dokploy_mount_all_named_by_application_id',
+    title: 'List Named Mounts by Application',
+    description: 'List named mounts attached to a Dokploy application. Requires the application ID.',
+    schema: z
+        .object({
+        applicationId: z.string().min(1).describe('Application ID'),
+    })
+        .strict(),
+    endpoint: '/mounts.allNamedByApplicationId',
+});
 const create = postTool({
     name: 'dokploy_mount_create',
     title: 'Create Mount',
@@ -25,13 +36,13 @@ const create = postTool({
             .min(1)
             .describe('Path inside the container where the mount is attached'),
         serviceId: z.string().min(1).describe('ID of the service to attach the mount to'),
-        hostPath: z.string().optional().describe('Host path for bind mounts'),
-        volumeName: z.string().optional().describe('Volume name for volume mounts'),
-        content: z.string().optional().describe('File content for file mounts'),
+        hostPath: z.string().nullable().optional().describe('Host path for bind mounts'),
+        volumeName: z.string().nullable().optional().describe('Volume name for volume mounts'),
+        content: z.string().nullable().optional().describe('File content for file mounts'),
+        filePath: z.string().nullable().optional().describe('File path for file mounts'),
         serviceType: z
             .enum(['application', 'postgres', 'mysql', 'mariadb', 'mongo', 'redis', 'compose'])
             .optional()
-            .default('application')
             .describe('Type of service the mount belongs to'),
     })
         .strict(),
@@ -45,14 +56,40 @@ const update = postTool({
         .object({
         mountId,
         type: mountTypeEnum.optional().describe('New mount type'),
-        mountPath: z.string().optional().describe('New path inside the container'),
-        hostPath: z.string().optional().describe('New host path for bind mounts'),
-        volumeName: z.string().optional().describe('New volume name for volume mounts'),
-        content: z.string().optional().describe('New file content for file mounts'),
+        mountPath: z.string().min(1).optional().describe('New path inside the container'),
+        hostPath: z.string().nullable().optional().describe('New host path for bind mounts'),
+        volumeName: z.string().nullable().optional().describe('New volume name for volume mounts'),
+        filePath: z.string().nullable().optional().describe('New file path for file mounts'),
+        content: z.string().nullable().optional().describe('New file content for file mounts'),
+        serviceType: z
+            .enum(['application', 'postgres', 'mysql', 'mariadb', 'mongo', 'redis', 'compose'])
+            .optional()
+            .describe('Type of service the mount belongs to'),
+        applicationId: z.string().nullable().optional().describe('Application ID'),
+        postgresId: z.string().nullable().optional().describe('Postgres ID'),
+        mariadbId: z.string().nullable().optional().describe('MariaDB ID'),
+        mongoId: z.string().nullable().optional().describe('MongoDB ID'),
+        mysqlId: z.string().nullable().optional().describe('MySQL ID'),
+        redisId: z.string().nullable().optional().describe('Redis ID'),
+        composeId: z.string().nullable().optional().describe('Compose ID'),
     })
         .strict(),
     endpoint: '/mounts.update',
 });
+const listByServiceId = getTool({
+    name: 'dokploy_mount_list_by_service_id',
+    title: 'List Mounts by Service',
+    description: 'List mounts for a Dokploy service. Requires the service ID and the service type.',
+    schema: z
+        .object({
+        serviceId: z.string().min(1).describe('Service ID'),
+        serviceType: z
+            .enum(['application', 'postgres', 'mysql', 'mariadb', 'mongo', 'redis', 'compose'])
+            .describe('Service type'),
+    })
+        .strict(),
+    endpoint: '/mounts.listByServiceId',
+});
 const remove = postTool({
     name: 'dokploy_mount_remove',
     title: 'Remove Mount',
@@ -62,4 +99,11 @@ const remove = postTool({
     annotations: { destructiveHint: true },
 });
 // ── export ───────────────────────────────────────────────────────────
-export const mountsTools = [one, create, update, remove];
+export const mountsTools = [
+    one,
+    allNamedByApplicationId,
+    create,
+    update,
+    listByServiceId,
+    remove,
+];

package/dist/tools/mysql.js

@@ -9,6 +9,6 @@ export const mysqlTools = createDatabaseTools({
         databaseName: z.string().min(1).describe('Name of the database to create'),
         databaseUser: z.string().min(1).describe('Database user'),
         databasePassword: z.string().min(1).describe('Database password'),
-        databaseRootPassword: z.string().min(1).describe('Root password for MySQL'),
+        databaseRootPassword: z.string().min(1).optional().describe('Root password for MySQL'),
     }),
 });

package/dist/tools/notification.d.ts

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