@vibetools/dokploy-mcp 0.5.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.d.ts

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

package/dist/tools/mariadb.js

@@ -1,170 +1,14 @@
 import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-// ── helpers ──────────────────────────────────────────────────────────
-const mdbId = z.string().min(1).describe('Unique MariaDB database ID');
-const DB = 'mariadb';
-// ── tools ────────────────────────────────────────────────────────────
-const one = getTool({
-    name: `dokploy_${DB}_one`,
-    title: 'Get MariaDB Details',
-    description: 'Retrieve the full configuration and status details of a MariaDB database managed by Dokploy. Requires the unique MariaDB database ID. Returns all metadata including name, image, resource limits, environment variables, and current application status.',
-    schema: z.object({ mariadbId: mdbId }).strict(),
-    endpoint: `${DB}.one`,
-});
-const create = postTool({
-    name: `dokploy_${DB}_create`,
-    title: 'Create MariaDB Database',
-    description: 'Create a new MariaDB database instance inside a Dokploy project. Requires a display name, app-level identifier, database name, user credentials, root 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'),
+import { createDatabaseTools } from './_database.js';
+export const mariadbTools = createDatabaseTools({
+    type: 'mariadb',
+    idField: 'mariadbId',
+    displayName: 'MariaDB',
+    defaultImage: 'mariadb:11',
+    createFields: z.object({
         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'),
-        projectId: z.string().min(1).describe('Project ID to create the database in'),
-        dockerImage: z.string().optional().describe('Docker image (default: mariadb:11)'),
-        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 MariaDB Database',
-    description: 'Update the configuration of an existing MariaDB database in Dokploy. Requires the MariaDB 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({
-        mariadbId: mdbId,
-        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 MariaDB Database',
-    description: 'Permanently delete a MariaDB database from Dokploy. Requires the MariaDB 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({ mariadbId: mdbId }).strict(),
-    endpoint: `${DB}.remove`,
-    annotations: { destructiveHint: true },
-});
-const move = postTool({
-    name: `dokploy_${DB}_move`,
-    title: 'Move MariaDB Database',
-    description: 'Move a MariaDB database from its current project to a different project within Dokploy. Requires the MariaDB database ID and the destination project ID. The database configuration and data remain intact during the move. Returns the operation status.',
-    schema: z
-        .object({
-        mariadbId: mdbId,
-        targetProjectId: z.string().min(1).describe('Destination project ID'),
-    })
-        .strict(),
-    endpoint: `${DB}.move`,
-});
-const deploy = postTool({
-    name: `dokploy_${DB}_deploy`,
-    title: 'Deploy MariaDB Database',
-    description: 'Deploy a MariaDB database in Dokploy, pulling the configured Docker image and starting the container. Requires the MariaDB database ID. This triggers a full deployment lifecycle including image pull, container creation, and startup. Returns the deployment operation status.',
-    schema: z.object({ mariadbId: mdbId }).strict(),
-    endpoint: `${DB}.deploy`,
-});
-const start = postTool({
-    name: `dokploy_${DB}_start`,
-    title: 'Start MariaDB Database',
-    description: 'Start a previously stopped MariaDB database container in Dokploy. Requires the MariaDB database ID. The container will resume with its existing data and configuration. Returns the operation status.',
-    schema: z.object({ mariadbId: mdbId }).strict(),
-    endpoint: `${DB}.start`,
-});
-const stop = postTool({
-    name: `dokploy_${DB}_stop`,
-    title: 'Stop MariaDB Database',
-    description: 'Stop a currently running MariaDB database container in Dokploy. Requires the MariaDB 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({ mariadbId: mdbId }).strict(),
-    endpoint: `${DB}.stop`,
-    annotations: { destructiveHint: true },
-});
-const reload = postTool({
-    name: `dokploy_${DB}_reload`,
-    title: 'Reload MariaDB Database',
-    description: 'Reload the MariaDB database container in Dokploy without performing a full rebuild. Requires the MariaDB database ID and the app-level identifier. This restarts the container with its current configuration. Returns the operation status.',
-    schema: z
-        .object({
-        mariadbId: mdbId,
-        appName: z.string().min(1).describe('App-level identifier'),
-    })
-        .strict(),
-    endpoint: `${DB}.reload`,
-});
-const rebuild = postTool({
-    name: `dokploy_${DB}_rebuild`,
-    title: 'Rebuild MariaDB Database',
-    description: 'Rebuild the MariaDB database container from scratch in Dokploy. Requires the MariaDB 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({ mariadbId: mdbId }).strict(),
-    endpoint: `${DB}.rebuild`,
-});
-const changeStatus = postTool({
-    name: `dokploy_${DB}_change_status`,
-    title: 'Change MariaDB Status',
-    description: 'Manually set the application status of a MariaDB database in Dokploy. Requires the MariaDB 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({
-        mariadbId: mdbId,
-        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 MariaDB External Port',
-    description: 'Set or clear the external port mapping for a MariaDB database in Dokploy. Requires the MariaDB 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({
-        mariadbId: mdbId,
-        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 MariaDB Environment',
-    description: 'Overwrite the environment variables for a MariaDB database in Dokploy. Requires the MariaDB 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({
-        mariadbId: mdbId,
-        env: z.string().nullable().optional().describe('Environment variables as a string'),
-    })
-        .strict(),
-    endpoint: `${DB}.saveEnvironment`,
+        databaseRootPassword: z.string().min(1).optional().describe('Root password for MariaDB'),
+    }),
 });
-// ── export ───────────────────────────────────────────────────────────
-export const mariadbTools = [
-    one,
-    create,
-    update,
-    remove,
-    move,
-    deploy,
-    start,
-    stop,
-    reload,
-    rebuild,
-    changeStatus,
-    saveExternalPort,
-    saveEnvironment,
-];

package/dist/tools/mongo.d.ts

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