@vibetools/dokploy-mcp 0.4.0

package/dist/tools/domain.js

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── tools ────────────────────────────────────────────────────────────
+const create = postTool({
+    name: 'dokploy_domain_create',
+    title: 'Create Domain',
+    description: 'Create a new domain configuration for an application or compose service. Requires the hostname, HTTPS setting, and certificate type. Optionally specify path-based routing, a target port, and the application or compose service to attach it to. Returns the created domain object.',
+    schema: z
+        .object({
+        host: z.string().min(1).describe('The domain hostname (e.g., app.example.com)'),
+        https: z.boolean().describe('Whether to enable HTTPS'),
+        certificateType: z.enum(['letsencrypt', 'none', 'custom']).describe('SSL certificate type'),
+        stripPath: z.boolean().describe('Whether to strip the path prefix when forwarding'),
+        path: z.string().optional().describe('URL path prefix for routing'),
+        port: z.number().nullable().optional().describe('Target port on the container'),
+        applicationId: z.string().optional().describe('Application ID to attach the domain to'),
+        composeId: z.string().optional().describe('Compose service ID to attach the domain to'),
+        serviceName: z.string().optional().describe('Service name within a compose deployment'),
+        customCertResolver: z
+            .string()
+            .nullable()
+            .optional()
+            .describe('Custom certificate resolver name'),
+        domainType: z.string().optional().describe('Domain type'),
+        previewDeploymentId: z.string().optional().describe('Preview deployment ID'),
+        internalPath: z.string().optional().describe('Internal path for routing'),
+    })
+        .strict(),
+    endpoint: '/domain.create',
+});
+const one = getTool({
+    name: 'dokploy_domain_one',
+    title: 'Get Domain',
+    description: 'Get detailed information about a single domain by its ID. Returns the full domain configuration including hostname, HTTPS settings, certificate type, routing rules, and the associated application or compose service.',
+    schema: z
+        .object({
+        domainId: z.string().min(1).describe('The unique domain ID'),
+    })
+        .strict(),
+    endpoint: '/domain.one',
+});
+const byApplicationId = getTool({
+    name: 'dokploy_domain_by_application_id',
+    title: 'List Domains by Application',
+    description: 'List all domains attached to a specific application. Requires the application ID. Returns an array of domain objects with their hostnames, HTTPS settings, certificate types, and routing configurations.',
+    schema: z
+        .object({
+        applicationId: z.string().min(1).describe('The unique application ID'),
+    })
+        .strict(),
+    endpoint: '/domain.byApplicationId',
+});
+const byComposeId = getTool({
+    name: 'dokploy_domain_by_compose_id',
+    title: 'List Domains by Compose Service',
+    description: 'List all domains attached to a specific compose service. Requires the compose service ID. Returns an array of domain objects with their hostnames, HTTPS settings, certificate types, and routing configurations.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/domain.byComposeId',
+});
+const update = postTool({
+    name: 'dokploy_domain_update',
+    title: 'Update Domain',
+    description: 'Update an existing domain configuration. Requires the domain ID along with the hostname, HTTPS setting, certificate type, and strip path option. Optionally modify the path prefix, port, certificate resolver, service name, and routing settings. Returns the updated domain object.',
+    schema: z
+        .object({
+        domainId: z.string().min(1).describe('The unique domain ID'),
+        host: z.string().min(1).describe('The domain hostname'),
+        https: z.boolean().describe('Whether to enable HTTPS'),
+        certificateType: z.enum(['letsencrypt', 'none', 'custom']).describe('SSL certificate type'),
+        stripPath: z.boolean().describe('Whether to strip the path prefix'),
+        path: z.string().optional().describe('URL path prefix for routing'),
+        port: z.number().nullable().optional().describe('Target port on the container'),
+        customCertResolver: z
+            .string()
+            .nullable()
+            .optional()
+            .describe('Custom certificate resolver name'),
+        serviceName: z.string().optional().describe('Service name within a compose deployment'),
+        domainType: z.string().optional().describe('Domain type'),
+        internalPath: z.string().optional().describe('Internal path for routing'),
+    })
+        .strict(),
+    endpoint: '/domain.update',
+});
+const deleteDomain = postTool({
+    name: 'dokploy_domain_delete',
+    title: 'Delete Domain',
+    description: 'Permanently delete a domain configuration. This removes the domain routing and any associated SSL certificates. This action is irreversible. Requires the domain ID.',
+    schema: z
+        .object({
+        domainId: z.string().min(1).describe('The unique domain ID to delete'),
+    })
+        .strict(),
+    endpoint: '/domain.delete',
+    annotations: { destructiveHint: true },
+});
+const validateDomain = postTool({
+    name: 'dokploy_domain_validate',
+    title: 'Validate Domain DNS',
+    description: "Validate that a domain's DNS records are correctly configured and pointing to the expected server. Requires the domain name and optionally accepts the expected server IP address. Returns the validation result indicating whether DNS resolution matches.",
+    schema: z
+        .object({
+        domain: z.string().min(1).describe('The domain name to validate'),
+        serverIp: z.string().optional().describe('Expected server IP address for DNS validation'),
+    })
+        .strict(),
+    endpoint: '/domain.validateDomain',
+});
+const generateDomain = postTool({
+    name: 'dokploy_domain_generate',
+    title: 'Generate Domain',
+    description: "Generate a default domain for an application using the server's configured base domain. This automatically creates and attaches a subdomain to the specified application. Requires the application ID. Returns the generated domain configuration.",
+    schema: z
+        .object({
+        applicationId: z.string().min(1).describe('The unique application ID'),
+    })
+        .strict(),
+    endpoint: '/domain.generateDomain',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const domainTools = [
+    create,
+    one,
+    byApplicationId,
+    byComposeId,
+    update,
+    deleteDomain,
+    validateDomain,
+    generateDomain,
+];

package/dist/tools/index.d.ts

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

package/dist/tools/index.js

@@ -0,0 +1,48 @@
+import { adminTools } from './admin.js';
+import { applicationTools } from './application.js';
+import { backupTools } from './backup.js';
+import { certificatesTools } from './certificates.js';
+import { clusterTools } from './cluster.js';
+import { composeTools } from './compose.js';
+import { deploymentTools } from './deployment.js';
+import { destinationTools } from './destination.js';
+import { dockerTools } from './docker.js';
+import { domainTools } from './domain.js';
+import { mariadbTools } from './mariadb.js';
+import { mongoTools } from './mongo.js';
+import { mountsTools } from './mounts.js';
+import { mysqlTools } from './mysql.js';
+import { portTools } from './port.js';
+import { postgresTools } from './postgres.js';
+import { projectTools } from './project.js';
+import { redirectsTools } from './redirects.js';
+import { redisTools } from './redis.js';
+import { registryTools } from './registry.js';
+import { securityTools } from './security.js';
+import { settingsTools } from './settings.js';
+import { userTools } from './user.js';
+export const allTools = [
+    ...projectTools,
+    ...applicationTools,
+    ...composeTools,
+    ...domainTools,
+    ...postgresTools,
+    ...mysqlTools,
+    ...mariadbTools,
+    ...mongoTools,
+    ...redisTools,
+    ...deploymentTools,
+    ...dockerTools,
+    ...certificatesTools,
+    ...registryTools,
+    ...destinationTools,
+    ...backupTools,
+    ...mountsTools,
+    ...portTools,
+    ...redirectsTools,
+    ...securityTools,
+    ...clusterTools,
+    ...settingsTools,
+    ...adminTools,
+    ...userTools,
+];

package/dist/tools/mariadb.d.ts

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

package/dist/tools/mariadb.js

@@ -0,0 +1,170 @@
+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'),
+        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`,
+});
+// ── export ───────────────────────────────────────────────────────────
+export const mariadbTools = [
+    one,
+    create,
+    update,
+    remove,
+    move,
+    deploy,
+    start,
+    stop,
+    reload,
+    rebuild,
+    changeStatus,
+    saveExternalPort,
+    saveEnvironment,
+];

package/dist/tools/mongo.d.ts

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

package/dist/tools/mongo.js

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

package/dist/tools/mounts.d.ts

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

package/dist/tools/mounts.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── helpers ──────────────────────────────────────────────────────────
+const mountId = z.string().min(1).describe('Unique mount ID');
+const mountTypeEnum = z
+    .enum(['bind', 'volume', 'file'])
+    .describe('Mount type: bind, volume, or file');
+// ── tools ────────────────────────────────────────────────────────────
+const one = getTool({
+    name: 'dokploy_mount_one',
+    title: 'Get Mount',
+    description: 'Retrieve the full configuration of a specific mount by its unique ID. Requires the mountId parameter. Returns the mount object including its type (bind, volume, or file), container path, host path or volume name, and associated service ID.',
+    schema: z.object({ mountId }).strict(),
+    endpoint: '/mounts.one',
+});
+const create = postTool({
+    name: 'dokploy_mount_create',
+    title: 'Create Mount',
+    description: 'Create a new mount for a Dokploy service. Supports bind mounts (host path to container), volume mounts (named Docker volumes), and file mounts (inline file content). Requires the mount type, container path, and service ID. Returns the created mount configuration.',
+    schema: z
+        .object({
+        type: mountTypeEnum,
+        mountPath: z
+            .string()
+            .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'),
+        serviceType: z
+            .enum(['application', 'postgres', 'mysql', 'mariadb', 'mongo', 'redis', 'compose'])
+            .optional()
+            .default('application')
+            .describe('Type of service the mount belongs to'),
+    })
+        .strict(),
+    endpoint: '/mounts.create',
+});
+const update = postTool({
+    name: 'dokploy_mount_update',
+    title: 'Update Mount',
+    description: 'Update an existing mount configuration for a Dokploy service. Requires the mountId of the mount to modify. Optionally update the mount type, container path, host path (for bind mounts), volume name (for volume mounts), or file content (for file mounts). Returns the updated mount configuration.',
+    schema: z
+        .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'),
+    })
+        .strict(),
+    endpoint: '/mounts.update',
+});
+const remove = postTool({
+    name: 'dokploy_mount_remove',
+    title: 'Remove Mount',
+    description: 'Permanently remove a mount from a Dokploy service. This action is irreversible and detaches the mount from the service container. Requires the mountId parameter. The underlying host path, volume, or file content is not automatically deleted.',
+    schema: z.object({ mountId }).strict(),
+    endpoint: '/mounts.remove',
+    annotations: { destructiveHint: true },
+});
+// ── export ───────────────────────────────────────────────────────────
+export const mountsTools = [one, create, update, remove];

package/dist/tools/mysql.d.ts

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