@vibetools/dokploy-mcp 0.4.0

package/dist/tools/backup.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── helpers ──────────────────────────────────────────────────────────
+const backupId = z.string().min(1).describe('Unique backup ID');
+// ── tools ────────────────────────────────────────────────────────────
+const one = getTool({
+    name: 'dokploy_backup_one',
+    title: 'Get Backup Configuration',
+    description: 'Retrieve the full details of a specific backup configuration by its unique ID. Requires the backupId parameter. Returns the backup object including its schedule, prefix, destination, database type, and enabled status.',
+    schema: z.object({ backupId }).strict(),
+    endpoint: '/backup.one',
+});
+const create = postTool({
+    name: 'dokploy_backup_create',
+    title: 'Create Backup Schedule',
+    description: 'Create a new scheduled backup configuration for a database service in Dokploy. Requires a cron schedule expression, file name prefix, destination ID, database name, and database type (postgres, mysql, mariadb, or mongo). Optionally accepts the specific database service ID and an enabled flag. Returns the created backup configuration.',
+    schema: z
+        .object({
+        schedule: z.string().min(1).describe('Cron schedule expression for the backup'),
+        prefix: z.string().min(1).describe('Prefix for backup file names'),
+        destinationId: z.string().min(1).describe('Destination ID where backups will be stored'),
+        database: z.string().min(1).describe('Name of the database to back up'),
+        databaseType: z
+            .enum(['postgres', 'mariadb', 'mysql', 'mongo'])
+            .describe('Type of the database'),
+        enabled: z.boolean().optional().describe('Whether the backup is enabled'),
+        postgresId: z
+            .string()
+            .optional()
+            .describe('Postgres database ID (when databaseType is postgres)'),
+        mysqlId: z.string().optional().describe('MySQL database ID (when databaseType is mysql)'),
+        mariadbId: z
+            .string()
+            .optional()
+            .describe('MariaDB database ID (when databaseType is mariadb)'),
+        mongoId: z.string().optional().describe('MongoDB database ID (when databaseType is mongo)'),
+    })
+        .strict(),
+    endpoint: '/backup.create',
+});
+const update = postTool({
+    name: 'dokploy_backup_update',
+    title: 'Update Backup Schedule',
+    description: 'Update an existing backup schedule configuration. Requires the backupId along with the updated cron schedule, file name prefix, destination ID, and database name. Optionally accepts an enabled flag to activate or deactivate the schedule. Returns the updated backup configuration.',
+    schema: z
+        .object({
+        backupId,
+        schedule: z.string().min(1).describe('Cron schedule expression for the backup'),
+        prefix: z.string().min(1).describe('Prefix for backup file names'),
+        destinationId: z.string().min(1).describe('Destination ID where backups will be stored'),
+        database: z.string().min(1).describe('Name of the database to back up'),
+        enabled: z.boolean().optional().describe('Whether the backup is enabled'),
+    })
+        .strict(),
+    endpoint: '/backup.update',
+});
+const remove = postTool({
+    name: 'dokploy_backup_remove',
+    title: 'Remove Backup Schedule',
+    description: 'Permanently remove a backup schedule configuration from Dokploy. This action is irreversible and stops all future scheduled backups for this configuration. Requires the backupId parameter. Previously created backup files at the destination are not deleted.',
+    schema: z.object({ backupId }).strict(),
+    endpoint: '/backup.remove',
+    annotations: { destructiveHint: true },
+});
+const manualBackupPostgres = postTool({
+    name: 'dokploy_backup_manual_postgres',
+    title: 'Manual Postgres Backup',
+    description: 'Trigger an immediate manual backup of a PostgreSQL database. Requires the backupId of an existing backup configuration that specifies the destination and database details. The backup runs asynchronously and stores the dump file at the configured S3 destination.',
+    schema: z.object({ backupId }).strict(),
+    endpoint: '/backup.manualBackupPostgres',
+});
+const manualBackupMySql = postTool({
+    name: 'dokploy_backup_manual_mysql',
+    title: 'Manual MySQL Backup',
+    description: 'Trigger an immediate manual backup of a MySQL database. Requires the backupId of an existing backup configuration that specifies the destination and database details. The backup runs asynchronously and stores the dump file at the configured S3 destination.',
+    schema: z.object({ backupId }).strict(),
+    endpoint: '/backup.manualBackupMySql',
+});
+const manualBackupMariadb = postTool({
+    name: 'dokploy_backup_manual_mariadb',
+    title: 'Manual MariaDB Backup',
+    description: 'Trigger an immediate manual backup of a MariaDB database. Requires the backupId of an existing backup configuration that specifies the destination and database details. The backup runs asynchronously and stores the dump file at the configured S3 destination.',
+    schema: z.object({ backupId }).strict(),
+    endpoint: '/backup.manualBackupMariadb',
+});
+const manualBackupMongo = postTool({
+    name: 'dokploy_backup_manual_mongo',
+    title: 'Manual MongoDB Backup',
+    description: 'Trigger an immediate manual backup of a MongoDB database. Requires the backupId of an existing backup configuration that specifies the destination and database details. The backup runs asynchronously and stores the dump file at the configured S3 destination.',
+    schema: z.object({ backupId }).strict(),
+    endpoint: '/backup.manualBackupMongo',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const backupTools = [
+    one,
+    create,
+    update,
+    remove,
+    manualBackupPostgres,
+    manualBackupMySql,
+    manualBackupMariadb,
+    manualBackupMongo,
+];

package/dist/tools/certificates.d.ts

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

package/dist/tools/certificates.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── tools ────────────────────────────────────────────────────────────
+const all = getTool({
+    name: 'dokploy_certificate_all',
+    title: 'List Certificates',
+    description: 'List all SSL/TLS certificates managed by Dokploy. Returns an array of certificate objects including their names, expiration dates, associated domains, and auto-renewal status. Takes no parameters. Useful for auditing certificate coverage across your deployments.',
+    schema: z.object({}).strict(),
+    endpoint: '/certificates.all',
+});
+const one = getTool({
+    name: 'dokploy_certificate_one',
+    title: 'Get Certificate Details',
+    description: 'Get the full details of a specific SSL/TLS certificate by its unique ID. Returns the certificate name, PEM data, private key reference, associated domain, expiration date, and auto-renewal configuration. Requires the certificate ID.',
+    schema: z
+        .object({
+        certificateId: z.string().min(1).describe('Unique certificate ID'),
+    })
+        .strict(),
+    endpoint: '/certificates.one',
+});
+const create = postTool({
+    name: 'dokploy_certificate_create',
+    title: 'Create Certificate',
+    description: 'Create a new SSL/TLS certificate in Dokploy. Requires the certificate name, PEM-encoded certificate data, and private key. Optionally accepts a certificate ID, filesystem path, and auto-renewal flag. Returns the newly created certificate object.',
+    schema: z
+        .object({
+        name: z.string().min(1).describe('Display name for the certificate'),
+        certificateData: z.string().min(1).describe('The certificate data (PEM format)'),
+        privateKey: z.string().min(1).describe('The private key for the certificate'),
+        certificateId: z.string().min(1).optional().describe('Optional certificate ID to assign'),
+        certificatePath: z
+            .string()
+            .optional()
+            .describe('Optional filesystem path for the certificate'),
+        autoRenew: z.boolean().optional().describe('Whether to automatically renew the certificate'),
+    })
+        .strict(),
+    endpoint: '/certificates.create',
+});
+const remove = postTool({
+    name: 'dokploy_certificate_remove',
+    title: 'Remove Certificate',
+    description: 'Permanently remove an SSL/TLS certificate from Dokploy. This action is irreversible and will delete the certificate data and private key. Requires the certificate ID. Any domains using this certificate will lose their TLS configuration.',
+    schema: z
+        .object({
+        certificateId: z.string().min(1).describe('Unique certificate ID to remove'),
+    })
+        .strict(),
+    endpoint: '/certificates.remove',
+    annotations: { destructiveHint: true },
+});
+// ── export ───────────────────────────────────────────────────────────
+export const certificatesTools = [all, one, create, remove];

package/dist/tools/cluster.d.ts

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

package/dist/tools/cluster.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── tools ────────────────────────────────────────────────────────────
+const getNodes = getTool({
+    name: 'dokploy_cluster_get_nodes',
+    title: 'List Cluster Nodes',
+    description: 'List all nodes in the Docker Swarm cluster. No parameters required. Returns an array of node objects including each node ID, hostname, role (manager or worker), availability status, and resource information.',
+    schema: z.object({}).strict(),
+    endpoint: '/cluster.getNodes',
+});
+const addWorker = getTool({
+    name: 'dokploy_cluster_add_worker',
+    title: 'Get Add Worker Command',
+    description: 'Get the Docker Swarm join command to add a new worker node to the cluster. No parameters required. Returns the full docker swarm join command with the appropriate token and manager address that should be executed on the new worker machine.',
+    schema: z.object({}).strict(),
+    endpoint: '/cluster.addWorker',
+});
+const addManager = getTool({
+    name: 'dokploy_cluster_add_manager',
+    title: 'Get Add Manager Command',
+    description: 'Get the Docker Swarm join command to add a new manager node to the cluster. No parameters required. Returns the full docker swarm join command with the appropriate manager token and address that should be executed on the new manager machine.',
+    schema: z.object({}).strict(),
+    endpoint: '/cluster.addManager',
+});
+const removeWorker = postTool({
+    name: 'dokploy_cluster_remove_worker',
+    title: 'Remove Worker Node',
+    description: 'Remove a worker node from the Docker Swarm cluster. This action is irreversible and any services running on the node will be rescheduled to other available nodes. Requires the nodeId parameter identifying the worker to remove. Returns a confirmation of the removal.',
+    schema: z
+        .object({
+        nodeId: z.string().min(1).describe('ID of the worker node to remove from the cluster'),
+    })
+        .strict(),
+    endpoint: '/cluster.removeWorker',
+    annotations: { destructiveHint: true },
+});
+// ── export ───────────────────────────────────────────────────────────
+export const clusterTools = [getNodes, addWorker, addManager, removeWorker];

package/dist/tools/compose.d.ts

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

package/dist/tools/compose.js

@@ -0,0 +1,213 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── tools ────────────────────────────────────────────────────────────
+const create = postTool({
+    name: 'dokploy_compose_create',
+    title: 'Create Compose Service',
+    description: 'Create a new Docker Compose service within a project. Requires a service name and project ID. Optionally specify the compose type (docker-compose or stack), a custom app name, and a target server ID. Returns the newly created compose service object.',
+    schema: z
+        .object({
+        name: z.string().min(1).describe('The name of the compose service'),
+        projectId: z.string().min(1).describe('The project ID to create the compose service in'),
+        description: z.string().nullable().optional().describe('Compose service description'),
+        composeType: z
+            .enum(['docker-compose', 'stack'])
+            .optional()
+            .describe('Compose type: docker-compose or stack'),
+        appName: z.string().optional().describe('Custom app name (auto-generated if not provided)'),
+        serverId: z.string().nullable().optional().describe('Target server ID for deployment'),
+    })
+        .strict(),
+    endpoint: '/compose.create',
+});
+const one = getTool({
+    name: 'dokploy_compose_one',
+    title: 'Get Compose Service',
+    description: 'Get detailed information about a single compose service by its ID. Returns the full compose service configuration including its source type, environment variables, deployment status, and associated project.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.one',
+});
+const update = postTool({
+    name: 'dokploy_compose_update',
+    title: 'Update Compose Service',
+    description: 'Update an existing compose service configuration. Accepts the compose service ID and any combination of fields to modify, including name, environment variables, compose file content, source type, Git repository settings, and auto-deploy preferences. Returns the updated compose service object.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+        name: z.string().optional().describe('Compose service name'),
+        appName: z.string().optional().describe('Internal app name'),
+        description: z.string().nullable().optional().describe('Service description'),
+        env: z.string().nullable().optional().describe('Environment variables'),
+        composeFile: z.string().nullable().optional().describe('Docker Compose file content'),
+        sourceType: z
+            .enum(['git', 'github', 'raw'])
+            .optional()
+            .describe('Source type for the compose file'),
+        composeType: z
+            .enum(['docker-compose', 'stack'])
+            .optional()
+            .describe('Compose type: docker-compose or stack'),
+        repository: z.string().optional().describe('Git repository name'),
+        owner: z.string().optional().describe('Git repository owner'),
+        branch: z.string().optional().describe('Git branch'),
+        autoDeploy: z.boolean().optional().describe('Whether auto-deploy is enabled'),
+        customGitUrl: z.string().optional().describe('Custom Git repository URL'),
+        customGitBranch: z.string().optional().describe('Custom Git branch'),
+        customGitSSHKey: z
+            .string()
+            .nullable()
+            .optional()
+            .describe('SSH key for custom Git authentication'),
+        command: z.string().nullable().optional().describe('Custom command override'),
+        composePath: z.string().optional().describe('Path to the compose file within the repo'),
+        composeStatus: z.string().optional().describe('Compose service status'),
+        projectId: z.string().optional().describe('Project ID'),
+    })
+        .strict(),
+    endpoint: '/compose.update',
+});
+const deleteCompose = postTool({
+    name: 'dokploy_compose_delete',
+    title: 'Delete Compose Service',
+    description: 'Permanently delete a compose service and all of its associated data, including containers, volumes, and configuration. This action is irreversible. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID to delete'),
+    })
+        .strict(),
+    endpoint: '/compose.delete',
+    annotations: { destructiveHint: true },
+});
+const deploy = postTool({
+    name: 'dokploy_compose_deploy',
+    title: 'Deploy Compose Service',
+    description: 'Deploy a Docker Compose service by triggering a build and run cycle. Requires the compose service ID. Returns the deployment status and any build logs produced during the deployment process.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID to deploy'),
+    })
+        .strict(),
+    endpoint: '/compose.deploy',
+});
+const redeploy = postTool({
+    name: 'dokploy_compose_redeploy',
+    title: 'Redeploy Compose Service',
+    description: 'Redeploy a compose service by rebuilding all containers and restarting them. This is useful when you need to pick up configuration changes or force a fresh deployment. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID to redeploy'),
+    })
+        .strict(),
+    endpoint: '/compose.redeploy',
+});
+const stop = postTool({
+    name: 'dokploy_compose_stop',
+    title: 'Stop Compose Service',
+    description: 'Stop all running containers in a compose service. The containers and their data are preserved but will no longer be running or serving traffic. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID to stop'),
+    })
+        .strict(),
+    endpoint: '/compose.stop',
+    annotations: { destructiveHint: true },
+});
+const cleanQueues = postTool({
+    name: 'dokploy_compose_clean_queues',
+    title: 'Clean Compose Queues',
+    description: 'Clean the pending deployment queues for a compose service. This removes any queued deployment tasks that have not yet started. Useful for clearing stuck or unwanted deployments. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.cleanQueues',
+    annotations: { destructiveHint: true },
+});
+const randomizeCompose = postTool({
+    name: 'dokploy_compose_randomize',
+    title: 'Randomize Compose Names',
+    description: 'Randomize the service names within a compose deployment to avoid naming conflicts. An optional prefix can be provided to prepend to the randomized names. Requires the compose service ID. Returns the updated compose configuration.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+        prefix: z.string().optional().describe('Optional prefix for randomized names'),
+    })
+        .strict(),
+    endpoint: '/compose.randomizeCompose',
+});
+const getDefaultCommand = getTool({
+    name: 'dokploy_compose_get_default_command',
+    title: 'Get Default Command',
+    description: 'Retrieve the default deployment command for a compose service. This is the command that Dokploy uses to bring up the compose stack during deployment. Requires the compose service ID. Returns the command string.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.getDefaultCommand',
+});
+const refreshToken = postTool({
+    name: 'dokploy_compose_refresh_token',
+    title: 'Refresh Webhook Token',
+    description: 'Refresh the webhook token for a compose service. This invalidates the previous webhook URL and generates a new one. Useful when the existing webhook token has been compromised. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.refreshToken',
+});
+const deployTemplate = postTool({
+    name: 'dokploy_compose_deploy_template',
+    title: 'Deploy Compose Template',
+    description: 'Deploy a compose service from a predefined template. Templates provide pre-configured compose stacks for common applications. Requires a project ID and the template ID. Returns the created compose service with deployment status.',
+    schema: z
+        .object({
+        projectId: z.string().min(1).describe('The project ID to deploy the template in'),
+        id: z.string().min(1).describe('The template ID to deploy'),
+    })
+        .strict(),
+    endpoint: '/compose.deployTemplate',
+});
+const templates = getTool({
+    name: 'dokploy_compose_templates',
+    title: 'List Compose Templates',
+    description: 'List all available compose templates that can be deployed. Templates are pre-configured Docker Compose stacks for popular applications and services. Returns an array of template objects with their IDs, names, and descriptions.',
+    schema: z.object({}).strict(),
+    endpoint: '/compose.templates',
+});
+const saveEnvironment = postTool({
+    name: 'dokploy_compose_save_environment',
+    title: 'Save Environment Variables',
+    description: 'Save environment variables and Docker build arguments for a compose service. Environment variables are injected at runtime while build arguments are passed during the image build phase. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+        env: z.string().nullable().optional().describe('Environment variables'),
+        buildArgs: z.string().nullable().optional().describe('Docker build arguments'),
+    })
+        .strict(),
+    endpoint: '/compose.saveEnvironment',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const composeTools = [
+    create,
+    one,
+    update,
+    deleteCompose,
+    deploy,
+    redeploy,
+    stop,
+    cleanQueues,
+    randomizeCompose,
+    getDefaultCommand,
+    refreshToken,
+    deployTemplate,
+    templates,
+    saveEnvironment,
+];

package/dist/tools/deployment.d.ts

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

package/dist/tools/deployment.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { getTool } from './_factory.js';
+// ── tools ────────────────────────────────────────────────────────────
+const all = getTool({
+    name: 'dokploy_deployment_all',
+    title: 'List Application Deployments',
+    description: 'List all deployment records for a specific application in Dokploy. Each deployment includes build logs, status, timestamps, and the triggering event. Requires the application ID. Returns an array of deployment objects ordered by creation date.',
+    schema: z
+        .object({
+        applicationId: z.string().min(1).describe('The unique application ID'),
+    })
+        .strict(),
+    endpoint: '/deployment.all',
+});
+const allByCompose = getTool({
+    name: 'dokploy_deployment_all_by_compose',
+    title: 'List Compose Deployments',
+    description: 'List all deployment records for a specific Docker Compose service in Dokploy. Each deployment includes build logs, status, timestamps, and the triggering event. Requires the compose service ID. Returns an array of deployment objects ordered by creation date.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/deployment.allByCompose',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const deploymentTools = [all, allByCompose];

package/dist/tools/destination.d.ts

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

package/dist/tools/destination.js

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+// ── helpers ──────────────────────────────────────────────────────────
+const destinationBaseSchema = {
+    name: z.string().min(1).describe('Name for the S3 destination'),
+    accessKey: z.string().min(1).describe('S3 access key'),
+    bucket: z.string().min(1).describe('S3 bucket name'),
+    region: z.string().min(1).describe('S3 region'),
+    endpoint: z.string().min(1).describe('S3 endpoint URL'),
+    secretAccessKey: z.string().min(1).describe('S3 secret access key'),
+};
+// ── tools ────────────────────────────────────────────────────────────
+const all = getTool({
+    name: 'dokploy_destination_all',
+    title: 'List Backup Destinations',
+    description: 'List all S3-compatible backup destinations configured in Dokploy. Takes no parameters. Returns an array of destination objects including their IDs, names, bucket configurations, and connection details.',
+    schema: z.object({}).strict(),
+    endpoint: '/destination.all',
+});
+const one = getTool({
+    name: 'dokploy_destination_one',
+    title: 'Get Backup Destination',
+    description: 'Retrieve the full configuration of a specific backup destination by its unique ID. Requires the destinationId parameter. Returns the destination object with name, S3 bucket, region, endpoint, and credential details.',
+    schema: z
+        .object({
+        destinationId: z.string().min(1).describe('Unique destination ID'),
+    })
+        .strict(),
+    endpoint: '/destination.one',
+});
+const create = postTool({
+    name: 'dokploy_destination_create',
+    title: 'Create Backup Destination',
+    description: 'Create a new S3-compatible backup destination in Dokploy. Requires the destination name, S3 access key, secret access key, bucket name, region, and endpoint URL. Returns the newly created destination object with its assigned ID.',
+    schema: z
+        .object({
+        ...destinationBaseSchema,
+    })
+        .strict(),
+    endpoint: '/destination.create',
+});
+const update = postTool({
+    name: 'dokploy_destination_update',
+    title: 'Update Backup Destination',
+    description: 'Update an existing S3-compatible backup destination configuration. Requires the destinationId of the destination to modify along with the updated S3 credentials and bucket settings. Returns the updated destination object.',
+    schema: z
+        .object({
+        destinationId: z.string().min(1).describe('Unique destination ID to update'),
+        ...destinationBaseSchema,
+    })
+        .strict(),
+    endpoint: '/destination.update',
+});
+const remove = postTool({
+    name: 'dokploy_destination_remove',
+    title: 'Remove Backup Destination',
+    description: 'Permanently remove a backup destination from Dokploy. This action is irreversible and will delete the destination configuration. Requires the destinationId parameter. Any backup schedules referencing this destination should be updated or removed first.',
+    schema: z
+        .object({
+        destinationId: z.string().min(1).describe('Unique destination ID to remove'),
+    })
+        .strict(),
+    endpoint: '/destination.remove',
+    annotations: { destructiveHint: true },
+});
+const testConnection = postTool({
+    name: 'dokploy_destination_test_connection',
+    title: 'Test Destination Connection',
+    description: 'Test the connection to an S3-compatible backup destination using the provided credentials. Requires the destination name, access key, secret access key, bucket, region, and endpoint. Returns a success or failure status indicating whether the S3 bucket is reachable and writable.',
+    schema: z
+        .object({
+        ...destinationBaseSchema,
+    })
+        .strict(),
+    endpoint: '/destination.testConnection',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const destinationTools = [all, one, create, update, remove, testConnection];

package/dist/tools/docker.d.ts

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

package/dist/tools/docker.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { getTool } from './_factory.js';
+// ── tools ────────────────────────────────────────────────────────────
+const getContainers = getTool({
+    name: 'dokploy_docker_get_containers',
+    title: 'List Docker Containers',
+    description: 'List all Docker containers running on the Dokploy server. Returns container metadata including names, images, status, ports, and resource usage. Takes no parameters. Useful for getting an overview of all running and stopped containers.',
+    schema: z.object({}).strict(),
+    endpoint: '/docker.getContainers',
+});
+const getConfig = getTool({
+    name: 'dokploy_docker_get_config',
+    title: 'Get Docker Container Config',
+    description: 'Get the full configuration of a specific Docker container by its ID. Returns detailed container settings including environment variables, volumes, network configuration, and resource limits. Requires the Docker container ID.',
+    schema: z
+        .object({
+        containerId: z.string().min(1).describe('The Docker container ID'),
+    })
+        .strict(),
+    endpoint: '/docker.getConfig',
+});
+const getContainersByAppNameMatch = getTool({
+    name: 'dokploy_docker_get_containers_by_app_name_match',
+    title: 'Find Containers by App Name',
+    description: 'Find Docker containers whose name matches the given application name. Performs a substring match against container names to locate containers belonging to a specific app. Requires the app name string. Returns matching container objects with their metadata.',
+    schema: z
+        .object({
+        appName: z.string().min(1).describe('The app name to match against container names'),
+    })
+        .strict(),
+    endpoint: '/docker.getContainersByAppNameMatch',
+});
+const getContainersByAppLabel = getTool({
+    name: 'dokploy_docker_get_containers_by_app_label',
+    title: 'Find Containers by App Label',
+    description: 'Find Docker containers by their application label metadata. Searches for containers that have a matching app label, which is the recommended way to identify containers managed by Dokploy. Requires the app name label value. Returns matching container objects.',
+    schema: z
+        .object({
+        appName: z.string().min(1).describe('The app name label to search for'),
+    })
+        .strict(),
+    endpoint: '/docker.getContainersByAppLabel',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const dockerTools = [
+    getContainers,
+    getConfig,
+    getContainersByAppNameMatch,
+    getContainersByAppLabel,
+];

package/dist/tools/domain.d.ts

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