@vibetools/dokploy-mcp 1.0.0 → 2.0.0

package/dist/tools/cluster.js

@@ -1,38 +0,0 @@
-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

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

package/dist/tools/compose.js

@@ -1,213 +0,0 @@
-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

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

package/dist/tools/deployment.js

@@ -1,27 +0,0 @@
-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

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

package/dist/tools/destination.js

@@ -1,78 +0,0 @@
-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

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

package/dist/tools/docker.js

@@ -1,50 +0,0 @@
-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

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

package/dist/tools/domain.js

@@ -1,134 +0,0 @@
-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

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

package/dist/tools/index.js

@@ -1,48 +0,0 @@
-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

@@ -1 +0,0 @@
-export declare const mariadbTools: import("./_factory.js").ToolDefinition[];

package/dist/tools/mariadb.js

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-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'),
-    }),
-});

package/dist/tools/mongo.d.ts

@@ -1 +0,0 @@
-export declare const mongoTools: import("./_factory.js").ToolDefinition[];

package/dist/tools/mongo.js

@@ -1,12 +0,0 @@
-import { z } from 'zod';
-import { createDatabaseTools } from './_database.js';
-export const mongoTools = createDatabaseTools({
-    type: 'mongo',
-    idField: 'mongoId',
-    displayName: 'MongoDB',
-    defaultImage: 'mongo:6',
-    createFields: z.object({
-        databaseUser: z.string().min(1).describe('Database user'),
-        databasePassword: z.string().min(1).describe('Database password'),
-    }),
-});

package/dist/tools/mounts.d.ts

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