@vibetools/dokploy-mcp 1.0.0 → 1.2.0

package/dist/tools/compose.js

@@ -1,21 +1,35 @@
 import { z } from 'zod';
 import { getTool, postTool } from './_factory.js';
 // ── tools ────────────────────────────────────────────────────────────
+const appNameSchema = z
+    .string()
+    .min(1)
+    .max(63)
+    .regex(/^[a-zA-Z0-9._-]+$/)
+    .describe('Internal app name');
+const nullableString = z.string().nullable().optional();
+const nullableBoolean = z.boolean().nullable().optional();
+const nullableNumber = z.number().nullable().optional();
+const nullableStringArray = z.array(z.string()).nullable().optional();
 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.',
+    description: 'Create a new Docker Compose service within an environment. Requires a service name and environment ID. Optionally specify the compose type (docker-compose or stack), a custom app name, target server ID, and compose file content. 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'),
+        environmentId: z
+            .string()
+            .min(1)
+            .describe('The environment ID to create the compose service in'),
+        description: nullableString.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)'),
+        appName: appNameSchema.optional(),
         serverId: z.string().nullable().optional().describe('Target server ID for deployment'),
+        composeFile: z.string().optional().describe('Compose file content'),
     })
         .strict(),
     endpoint: '/compose.create',
@@ -39,33 +53,64 @@ const update = postTool({
         .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'),
+        appName: appNameSchema.optional(),
+        description: nullableString.describe('Service description'),
+        env: nullableString.describe('Environment variables'),
+        composeFile: z.string().optional().describe('Docker Compose file content'),
+        refreshToken: nullableString.describe('Webhook token'),
         sourceType: z
-            .enum(['git', 'github', 'raw'])
+            .enum(['git', 'github', 'gitlab', 'bitbucket', 'gitea', '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()
+        repository: nullableString.describe('Git repository name'),
+        owner: nullableString.describe('Git repository owner'),
+        branch: nullableString.describe('Git branch'),
+        autoDeploy: nullableBoolean.describe('Whether auto-deploy is enabled'),
+        gitlabProjectId: nullableNumber.describe('GitLab project ID'),
+        gitlabRepository: nullableString.describe('GitLab repository'),
+        gitlabOwner: nullableString.describe('GitLab owner'),
+        gitlabBranch: nullableString.describe('GitLab branch'),
+        gitlabPathNamespace: nullableString.describe('GitLab path namespace'),
+        bitbucketRepository: nullableString.describe('Bitbucket repository'),
+        bitbucketRepositorySlug: nullableString.describe('Bitbucket repository slug'),
+        bitbucketOwner: nullableString.describe('Bitbucket owner'),
+        bitbucketBranch: nullableString.describe('Bitbucket branch'),
+        giteaRepository: nullableString.describe('Gitea repository'),
+        giteaOwner: nullableString.describe('Gitea owner'),
+        giteaBranch: nullableString.describe('Gitea branch'),
+        customGitUrl: nullableString.describe('Custom Git repository URL'),
+        customGitBranch: nullableString.describe('Custom Git branch'),
+        customGitSSHKeyId: nullableString.describe('SSH key ID for custom Git authentication'),
+        command: z.string().optional().describe('Custom command override'),
+        enableSubmodules: z.boolean().optional().describe('Whether git submodules are enabled'),
+        composePath: z.string().optional().describe('Path to the compose file within the repo'),
+        suffix: z.string().optional().describe('Isolated deployment suffix'),
+        randomize: z.boolean().optional().describe('Whether to randomize service names'),
+        isolatedDeployment: z.boolean().optional().describe('Whether isolated deployment is enabled'),
+        isolatedDeploymentsVolume: z
+            .boolean()
+            .optional()
+            .describe('Whether isolated deployments get a dedicated volume'),
+        triggerType: z
+            .enum(['push', 'tag'])
             .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'),
+            .describe('Deployment trigger type'),
+        composeStatus: z
+            .enum(['idle', 'running', 'done', 'error'])
+            .optional()
+            .describe('Compose service status'),
+        environmentId: z.string().optional().describe('Environment ID'),
+        createdAt: z.string().optional().describe('Creation timestamp'),
+        watchPaths: nullableStringArray.describe('Paths to watch for deploy triggers'),
+        githubId: nullableString.describe('GitHub provider ID'),
+        gitlabId: nullableString.describe('GitLab provider ID'),
+        bitbucketId: nullableString.describe('Bitbucket provider ID'),
+        giteaId: nullableString.describe('Gitea provider ID'),
     })
         .strict(),
     endpoint: '/compose.update',
@@ -77,6 +122,7 @@ const deleteCompose = postTool({
     schema: z
         .object({
         composeId: z.string().min(1).describe('The unique compose service ID to delete'),
+        deleteVolumes: z.boolean().describe('Whether to delete attached volumes'),
     })
         .strict(),
     endpoint: '/compose.delete',
@@ -89,6 +135,8 @@ const deploy = postTool({
     schema: z
         .object({
         composeId: z.string().min(1).describe('The unique compose service ID to deploy'),
+        title: z.string().optional().describe('Optional deployment title'),
+        description: z.string().optional().describe('Optional deployment description'),
     })
         .strict(),
     endpoint: '/compose.deploy',
@@ -100,6 +148,8 @@ const redeploy = postTool({
     schema: z
         .object({
         composeId: z.string().min(1).describe('The unique compose service ID to redeploy'),
+        title: z.string().optional().describe('Optional deployment title'),
+        description: z.string().optional().describe('Optional deployment description'),
     })
         .strict(),
     endpoint: '/compose.redeploy',
@@ -131,11 +181,11 @@ const cleanQueues = postTool({
 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.',
+    description: 'Randomize the service names within a compose deployment to avoid naming conflicts. An optional suffix can be provided to append 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'),
+        suffix: z.string().optional().describe('Optional suffix for randomized names'),
     })
         .strict(),
     endpoint: '/compose.randomizeCompose',
@@ -165,11 +215,13 @@ const refreshToken = postTool({
 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.',
+    description: 'Deploy a compose service from a predefined template. Templates provide pre-configured compose stacks for common applications. Requires an environment 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'),
+        environmentId: z.string().min(1).describe('The environment ID to deploy the template in'),
+        serverId: z.string().optional().describe('Optional target server ID'),
         id: z.string().min(1).describe('The template ID to deploy'),
+        baseUrl: z.string().optional().describe('Optional base URL used by the template'),
     })
         .strict(),
     endpoint: '/compose.deployTemplate',
@@ -178,21 +230,193 @@ 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(),
+    schema: z
+        .object({
+        baseUrl: z.string().optional().describe('Optional base URL'),
+    })
+        .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.',
+const start = postTool({
+    name: 'dokploy_compose_start',
+    title: 'Start Compose Service',
+    description: 'Start a previously stopped compose service in Dokploy. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.start',
+});
+const move = postTool({
+    name: 'dokploy_compose_move',
+    title: 'Move Compose Service',
+    description: 'Move a compose service from its current environment to a different Dokploy environment. Requires the compose service ID and the target environment ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+        targetEnvironmentId: z.string().min(1).describe('The target environment ID'),
+    })
+        .strict(),
+    endpoint: '/compose.move',
+});
+const cancelDeployment = postTool({
+    name: 'dokploy_compose_cancel_deployment',
+    title: 'Cancel Compose Deployment',
+    description: 'Cancel an in-progress compose deployment in Dokploy. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.cancelDeployment',
+});
+const killBuild = postTool({
+    name: 'dokploy_compose_kill_build',
+    title: 'Kill Compose Build',
+    description: 'Stop an in-progress compose build in Dokploy. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.killBuild',
+    annotations: { destructiveHint: true },
+});
+const clearDeployments = postTool({
+    name: 'dokploy_compose_clear_deployments',
+    title: 'Clear Compose Deployments',
+    description: 'Clear stored deployment history for a compose service in Dokploy. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.clearDeployments',
+    annotations: { destructiveHint: true },
+});
+const disconnectGitProvider = postTool({
+    name: 'dokploy_compose_disconnect_git_provider',
+    title: 'Disconnect Compose Git Provider',
+    description: 'Disconnect the linked Git provider from a compose service in Dokploy. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.disconnectGitProvider',
+    annotations: { destructiveHint: true },
+});
+const search = getTool({
+    name: 'dokploy_compose_search',
+    title: 'Search Compose Services',
+    description: 'Search Dokploy compose services by free text or field-specific filters. Supports pagination through limit and offset.',
+    schema: z
+        .object({
+        q: z.string().optional().describe('Free-text query'),
+        name: z.string().optional().describe('Compose service name'),
+        appName: z.string().optional().describe('Internal app name'),
+        description: z.string().optional().describe('Compose service description'),
+        projectId: z.string().optional().describe('Project ID'),
+        environmentId: z.string().optional().describe('Environment ID'),
+        limit: z.number().min(1).max(100).optional().describe('Maximum number of results'),
+        offset: z.number().min(0).optional().describe('Number of results to skip'),
+    })
+        .strict(),
+    endpoint: '/compose.search',
+});
+const loadServices = getTool({
+    name: 'dokploy_compose_load_services',
+    title: 'Load Compose Services',
+    description: 'Load parsed service definitions for a compose service. Requires the compose service ID and optionally accepts a cache strategy.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+        type: z.enum(['fetch', 'cache']).optional().describe('Load strategy'),
+    })
+        .strict(),
+    endpoint: '/compose.loadServices',
+});
+const loadMountsByService = getTool({
+    name: 'dokploy_compose_load_mounts_by_service',
+    title: 'Load Mounts by Compose Service',
+    description: 'Load compose mounts for a specific service inside a compose stack. Requires the compose service ID and service name.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+        serviceName: z.string().min(1).describe('Compose service name'),
+    })
+        .strict(),
+    endpoint: '/compose.loadMountsByService',
+});
+const fetchSourceType = postTool({
+    name: 'dokploy_compose_fetch_source_type',
+    title: 'Fetch Compose Source Type',
+    description: 'Fetch and resolve the effective source type for a compose service in Dokploy. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.fetchSourceType',
+});
+const isolatedDeployment = postTool({
+    name: 'dokploy_compose_isolated_deployment',
+    title: 'Run Isolated Compose Deployment',
+    description: 'Create an isolated deployment variant for a compose service in Dokploy. Requires the compose service ID and optionally accepts a suffix.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+        suffix: z.string().optional().describe('Optional isolated deployment suffix'),
+    })
+        .strict(),
+    endpoint: '/compose.isolatedDeployment',
+});
+const getConvertedCompose = getTool({
+    name: 'dokploy_compose_get_converted_compose',
+    title: 'Get Converted Compose',
+    description: 'Retrieve the converted compose definition that Dokploy will deploy. Requires the compose service ID.',
+    schema: z
+        .object({
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.getConvertedCompose',
+});
+const getTags = getTool({
+    name: 'dokploy_compose_get_tags',
+    title: 'Get Compose Template Tags',
+    description: 'List available compose template tags. Optionally pass a base URL to target a specific template source.',
+    schema: z
+        .object({
+        baseUrl: z.string().optional().describe('Optional base URL'),
+    })
+        .strict(),
+    endpoint: '/compose.getTags',
+});
+const processTemplate = postTool({
+    name: 'dokploy_compose_process_template',
+    title: 'Process Compose Template',
+    description: 'Process a compose template payload for an existing compose service. Requires a base64 payload and the compose service ID.',
+    schema: z
+        .object({
+        base64: z.string().describe('Base64-encoded template payload'),
+        composeId: z.string().min(1).describe('The unique compose service ID'),
+    })
+        .strict(),
+    endpoint: '/compose.processTemplate',
+});
+const importCompose = postTool({
+    name: 'dokploy_compose_import',
+    title: 'Import Compose Definition',
+    description: 'Import a compose definition into an existing compose service. Requires a base64 payload and the compose service ID.',
     schema: z
         .object({
+        base64: z.string().describe('Base64-encoded compose payload'),
         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',
+    endpoint: '/compose.import',
 });
 // ── export ───────────────────────────────────────────────────────────
 export const composeTools = [
@@ -203,11 +427,25 @@ export const composeTools = [
     deploy,
     redeploy,
     stop,
+    start,
+    move,
+    cancelDeployment,
+    killBuild,
+    clearDeployments,
+    disconnectGitProvider,
     cleanQueues,
     randomizeCompose,
+    search,
+    loadServices,
+    loadMountsByService,
+    fetchSourceType,
+    isolatedDeployment,
+    getConvertedCompose,
+    getTags,
+    processTemplate,
+    importCompose,
     getDefaultCommand,
     refreshToken,
     deployTemplate,
     templates,
-    saveEnvironment,
 ];

package/dist/tools/deployment.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { getTool } from './_factory.js';
+import { getTool, postTool } from './_factory.js';
 // ── tools ────────────────────────────────────────────────────────────
 const all = getTool({
     name: 'dokploy_deployment_all',
@@ -23,5 +23,85 @@ const allByCompose = getTool({
         .strict(),
     endpoint: '/deployment.allByCompose',
 });
+const allByServer = getTool({
+    name: 'dokploy_deployment_all_by_server',
+    title: 'List Server Deployments',
+    description: 'List all deployment records associated with a specific Dokploy server. Requires the server ID.',
+    schema: z
+        .object({
+        serverId: z.string().min(1).describe('The unique server ID'),
+    })
+        .strict(),
+    endpoint: '/deployment.allByServer',
+});
+const allCentralized = getTool({
+    name: 'dokploy_deployment_all_centralized',
+    title: 'List Centralized Deployments',
+    description: 'List centralized deployments in Dokploy across supported entity types.',
+    schema: z.object({}).strict(),
+    endpoint: '/deployment.allCentralized',
+});
+const queueList = getTool({
+    name: 'dokploy_deployment_queue_list',
+    title: 'List Deployment Queue',
+    description: 'List queued deployment jobs in Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/deployment.queueList',
+});
+const allByType = getTool({
+    name: 'dokploy_deployment_all_by_type',
+    title: 'List Deployments by Type',
+    description: 'List deployments for a specific Dokploy entity type. Requires the entity ID and the entity type.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        type: z
+            .enum([
+            'application',
+            'compose',
+            'server',
+            'schedule',
+            'previewDeployment',
+            'backup',
+            'volumeBackup',
+        ])
+            .describe('Entity type'),
+    })
+        .strict(),
+    endpoint: '/deployment.allByType',
+});
+const killProcess = postTool({
+    name: 'dokploy_deployment_kill_process',
+    title: 'Kill Deployment Process',
+    description: 'Kill an in-progress deployment process in Dokploy. Requires the deployment ID.',
+    schema: z
+        .object({
+        deploymentId: z.string().min(1).describe('Deployment ID'),
+    })
+        .strict(),
+    endpoint: '/deployment.killProcess',
+    annotations: { destructiveHint: true },
+});
+const removeDeployment = postTool({
+    name: 'dokploy_deployment_remove_deployment',
+    title: 'Remove Deployment Record',
+    description: 'Remove a deployment record from Dokploy. Requires the deployment ID. This is a destructive action.',
+    schema: z
+        .object({
+        deploymentId: z.string().min(1).describe('Deployment ID'),
+    })
+        .strict(),
+    endpoint: '/deployment.removeDeployment',
+    annotations: { destructiveHint: true },
+});
 // ── export ───────────────────────────────────────────────────────────
-export const deploymentTools = [all, allByCompose];
+export const deploymentTools = [
+    all,
+    allByCompose,
+    allByServer,
+    allCentralized,
+    queueList,
+    allByType,
+    killProcess,
+    removeDeployment,
+];

package/dist/tools/docker.js

@@ -1,11 +1,15 @@
 import { z } from 'zod';
-import { getTool } from './_factory.js';
+import { getTool, postTool } 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(),
+    schema: z
+        .object({
+        serverId: z.string().optional().describe('Optional server ID'),
+    })
+        .strict(),
     endpoint: '/docker.getContainers',
 });
 const getConfig = getTool({
@@ -15,6 +19,7 @@ const getConfig = getTool({
     schema: z
         .object({
         containerId: z.string().min(1).describe('The Docker container ID'),
+        serverId: z.string().optional().describe('Optional server ID'),
     })
         .strict(),
     endpoint: '/docker.getConfig',
@@ -26,6 +31,8 @@ const getContainersByAppNameMatch = getTool({
     schema: z
         .object({
         appName: z.string().min(1).describe('The app name to match against container names'),
+        appType: z.enum(['stack', 'docker-compose']).optional().describe('App type'),
+        serverId: z.string().optional().describe('Optional server ID'),
     })
         .strict(),
     endpoint: '/docker.getContainersByAppNameMatch',
@@ -37,14 +44,67 @@ const getContainersByAppLabel = getTool({
     schema: z
         .object({
         appName: z.string().min(1).describe('The app name label to search for'),
+        serverId: z.string().optional().describe('Optional server ID'),
+        type: z.enum(['standalone', 'swarm']).describe('Container type'),
     })
         .strict(),
     endpoint: '/docker.getContainersByAppLabel',
 });
+const restartContainer = postTool({
+    name: 'dokploy_docker_restart_container',
+    title: 'Restart Docker Container',
+    description: 'Restart a Docker container managed by Dokploy. Requires the Docker container ID.',
+    schema: z
+        .object({
+        containerId: z
+            .string()
+            .min(1)
+            .regex(/^[a-zA-Z0-9.\-_]+$/)
+            .describe('Docker container ID'),
+    })
+        .strict(),
+    endpoint: '/docker.restartContainer',
+    annotations: { destructiveHint: true },
+});
+const getStackContainersByAppName = getTool({
+    name: 'dokploy_docker_get_stack_containers_by_app_name',
+    title: 'List Stack Containers by App Name',
+    description: 'List stack containers for a Dokploy application name. Requires the app name and optionally accepts a server ID.',
+    schema: z
+        .object({
+        appName: z
+            .string()
+            .min(1)
+            .regex(/^[a-zA-Z0-9.\-_]+$/)
+            .describe('Application name'),
+        serverId: z.string().optional().describe('Optional server ID'),
+    })
+        .strict(),
+    endpoint: '/docker.getStackContainersByAppName',
+});
+const getServiceContainersByAppName = getTool({
+    name: 'dokploy_docker_get_service_containers_by_app_name',
+    title: 'List Service Containers by App Name',
+    description: 'List service containers for a Dokploy application name. Requires the app name and optionally accepts a server ID.',
+    schema: z
+        .object({
+        appName: z
+            .string()
+            .min(1)
+            .regex(/^[a-zA-Z0-9.\-_]+$/)
+            .describe('Application name'),
+        serverId: z.string().optional().describe('Optional server ID'),
+    })
+        .strict(),
+    endpoint: '/docker.getServiceContainersByAppName',
+});
 // ── export ───────────────────────────────────────────────────────────
 export const dockerTools = [
     getContainers,
     getConfig,
     getContainersByAppNameMatch,
     getContainersByAppLabel,
+    restartContainer,
+    getStackContainersByAppName,
+    getServiceContainersByAppName,
 ];

package/dist/tools/domain.js

@@ -113,20 +113,33 @@ const validateDomain = postTool({
 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.",
+    description: "Generate a default domain for an app name using the server's configured base domain. Optionally scope generation to a specific server.",
     schema: z
         .object({
-        applicationId: z.string().min(1).describe('The unique application ID'),
+        appName: z.string().min(1).describe('App name'),
+        serverId: z.string().optional().describe('Optional server ID'),
     })
         .strict(),
     endpoint: '/domain.generateDomain',
 });
+const canGenerateTraefikMeDomains = getTool({
+    name: 'dokploy_domain_can_generate_traefik_me_domains',
+    title: 'Check Traefik.me Availability',
+    description: 'Check whether Dokploy can generate `traefik.me` domains for a given server. Requires the server ID.',
+    schema: z
+        .object({
+        serverId: z.string().describe('Server ID'),
+    })
+        .strict(),
+    endpoint: '/domain.canGenerateTraefikMeDomains',
+});
 // ── export ───────────────────────────────────────────────────────────
 export const domainTools = [
     create,
     one,
     byApplicationId,
     byComposeId,
+    canGenerateTraefikMeDomains,
     update,
     deleteDomain,
     validateDomain,

package/dist/tools/environment.d.ts

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