@vibetools/dokploy-mcp 1.2.0 → 2.0.0

package/dist/tools/docker.js

@@ -1,110 +0,0 @@
-import { z } from 'zod';
-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({
-        serverId: z.string().optional().describe('Optional server ID'),
-    })
-        .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'),
-        serverId: z.string().optional().describe('Optional server 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'),
-        appType: z.enum(['stack', 'docker-compose']).optional().describe('App type'),
-        serverId: z.string().optional().describe('Optional server ID'),
-    })
-        .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'),
-        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.d.ts

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

package/dist/tools/domain.js

@@ -1,147 +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 app name using the server's configured base domain. Optionally scope generation to a specific server.",
-    schema: z
-        .object({
-        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,
-    generateDomain,
-];

package/dist/tools/environment.d.ts

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

package/dist/tools/environment.js

@@ -1,104 +0,0 @@
-import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-const paginationLimit = z.number().min(1).max(100).optional().describe('Maximum number of results');
-const paginationOffset = z.number().min(0).optional().describe('Number of results to skip');
-const create = postTool({
-    name: 'dokploy_environment_create',
-    title: 'Create Environment',
-    description: 'Create a new environment inside a Dokploy project. Requires the project ID and environment name. Optionally set a description. Returns the created environment object.',
-    schema: z
-        .object({
-        name: z.string().min(1).describe('The environment name'),
-        description: z.string().optional().describe('Environment description'),
-        projectId: z.string().min(1).describe('The project ID'),
-    })
-        .strict(),
-    endpoint: '/environment.create',
-});
-const one = getTool({
-    name: 'dokploy_environment_one',
-    title: 'Get Environment',
-    description: 'Retrieve detailed information about a Dokploy environment by its ID. Returns the environment, services, and related project metadata.',
-    schema: z
-        .object({
-        environmentId: z.string().min(1).describe('The environment ID'),
-    })
-        .strict(),
-    endpoint: '/environment.one',
-});
-const byProjectId = getTool({
-    name: 'dokploy_environment_by_project_id',
-    title: 'List Environments by Project',
-    description: 'List all environments belonging to a Dokploy project. Requires the project ID. Returns the environments configured for that project.',
-    schema: z
-        .object({
-        projectId: z.string().min(1).describe('The project ID'),
-    })
-        .strict(),
-    endpoint: '/environment.byProjectId',
-});
-const remove = postTool({
-    name: 'dokploy_environment_remove',
-    title: 'Remove Environment',
-    description: 'Permanently remove a Dokploy environment. This action is destructive and may remove all services that belong to the environment. Requires the environment ID.',
-    schema: z
-        .object({
-        environmentId: z.string().min(1).describe('The environment ID'),
-    })
-        .strict(),
-    endpoint: '/environment.remove',
-    annotations: { destructiveHint: true },
-});
-const update = postTool({
-    name: 'dokploy_environment_update',
-    title: 'Update Environment',
-    description: 'Update an existing Dokploy environment. Requires the environment ID and accepts optional changes to the environment name, description, project assignment, and environment variables.',
-    schema: z
-        .object({
-        environmentId: z.string().min(1).describe('The environment ID'),
-        name: z.string().min(1).optional().describe('Environment name'),
-        description: z.string().optional().describe('Environment description'),
-        projectId: z.string().optional().describe('Project ID'),
-        env: z.string().optional().describe('Environment variables'),
-    })
-        .strict(),
-    endpoint: '/environment.update',
-});
-const duplicate = postTool({
-    name: 'dokploy_environment_duplicate',
-    title: 'Duplicate Environment',
-    description: 'Duplicate an existing Dokploy environment. Requires the source environment ID and a name for the new environment. Optionally set a description.',
-    schema: z
-        .object({
-        environmentId: z.string().min(1).describe('The source environment ID'),
-        name: z.string().min(1).describe('The new environment name'),
-        description: z.string().optional().describe('New environment description'),
-    })
-        .strict(),
-    endpoint: '/environment.duplicate',
-});
-const search = getTool({
-    name: 'dokploy_environment_search',
-    title: 'Search Environments',
-    description: 'Search Dokploy environments by free text or field-specific filters. Supports pagination through limit and offset.',
-    schema: z
-        .object({
-        q: z.string().optional().describe('Free-text query'),
-        name: z.string().optional().describe('Environment name'),
-        description: z.string().optional().describe('Environment description'),
-        projectId: z.string().optional().describe('Project ID'),
-        limit: paginationLimit,
-        offset: paginationOffset,
-    })
-        .strict(),
-    endpoint: '/environment.search',
-});
-export const environmentTools = [
-    create,
-    one,
-    byProjectId,
-    remove,
-    update,
-    duplicate,
-    search,
-];

package/dist/tools/git-provider.d.ts

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

package/dist/tools/git-provider.js

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-const getAll = getTool({
-    name: 'dokploy_git_provider_get_all',
-    title: 'List Git Providers',
-    description: 'List all Git provider integrations available in Dokploy, including provider metadata and linked platform records.',
-    schema: z.object({}).strict(),
-    endpoint: '/gitProvider.getAll',
-});
-const remove = postTool({
-    name: 'dokploy_git_provider_remove',
-    title: 'Remove Git Provider',
-    description: 'Remove a Git provider integration from Dokploy. Requires the Git provider ID. This is a destructive action.',
-    schema: z
-        .object({
-        gitProviderId: z.string().min(1).describe('Git provider ID'),
-    })
-        .strict(),
-    endpoint: '/gitProvider.remove',
-    annotations: { destructiveHint: true },
-});
-export const gitProviderTools = [getAll, remove];

package/dist/tools/github.d.ts

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

package/dist/tools/github.js

@@ -1,66 +0,0 @@
-import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-const githubIdSchema = z.string().min(1).describe('GitHub provider ID');
-const one = getTool({
-    name: 'dokploy_github_one',
-    title: 'Get GitHub Provider',
-    description: 'Retrieve a GitHub provider integration by its ID.',
-    schema: z.object({ githubId: githubIdSchema }).strict(),
-    endpoint: '/github.one',
-});
-const getGithubRepositories = getTool({
-    name: 'dokploy_github_get_github_repositories',
-    title: 'List GitHub Repositories',
-    description: 'List GitHub repositories available through a Dokploy GitHub provider integration. Requires the GitHub provider ID.',
-    schema: z.object({ githubId: githubIdSchema }).strict(),
-    endpoint: '/github.getGithubRepositories',
-});
-const getGithubBranches = getTool({
-    name: 'dokploy_github_get_github_branches',
-    title: 'List GitHub Branches',
-    description: 'List branches for a GitHub repository through Dokploy. Requires the repository name and owner. Optionally pass the GitHub provider ID.',
-    schema: z
-        .object({
-        repo: z.string().min(1).describe('Repository name'),
-        owner: z.string().min(1).describe('Repository owner'),
-        githubId: z.string().optional().describe('GitHub provider ID'),
-    })
-        .strict(),
-    endpoint: '/github.getGithubBranches',
-});
-const githubProviders = getTool({
-    name: 'dokploy_github_github_providers',
-    title: 'List GitHub Providers',
-    description: 'List GitHub provider integrations configured in Dokploy.',
-    schema: z.object({}).strict(),
-    endpoint: '/github.githubProviders',
-});
-const testConnection = postTool({
-    name: 'dokploy_github_test_connection',
-    title: 'Test GitHub Connection',
-    description: 'Test a Dokploy GitHub provider connection by its ID.',
-    schema: z.object({ githubId: githubIdSchema }).strict(),
-    endpoint: '/github.testConnection',
-});
-const update = postTool({
-    name: 'dokploy_github_update',
-    title: 'Update GitHub Provider',
-    description: 'Update a Dokploy GitHub provider integration. Requires the provider ID, display name, linked Git provider ID, and GitHub App name.',
-    schema: z
-        .object({
-        githubId: githubIdSchema,
-        name: z.string().min(1).describe('Provider display name'),
-        gitProviderId: z.string().min(1).describe('Git provider ID'),
-        githubAppName: z.string().min(1).describe('GitHub App name'),
-    })
-        .strict(),
-    endpoint: '/github.update',
-});
-export const githubTools = [
-    one,
-    getGithubRepositories,
-    getGithubBranches,
-    githubProviders,
-    testConnection,
-    update,
-];

package/dist/tools/gitlab.d.ts

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

package/dist/tools/gitlab.js

@@ -1,98 +0,0 @@
-import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-const nullableString = z.string().nullable().optional();
-const gitlabIdSchema = z.string().min(1).describe('GitLab provider ID');
-const create = postTool({
-    name: 'dokploy_gitlab_create',
-    title: 'Create GitLab Provider',
-    description: 'Create a new GitLab provider integration in Dokploy. Requires the auth ID, name, and GitLab URL. Additional OAuth and provider fields may also be supplied.',
-    schema: z
-        .object({
-        applicationId: z.string().optional().describe('Application ID'),
-        secret: z.string().optional().describe('OAuth client secret'),
-        groupName: z.string().optional().describe('GitLab group name'),
-        gitProviderId: z.string().optional().describe('Git provider ID'),
-        redirectUri: z.string().optional().describe('OAuth redirect URI'),
-        authId: z.string().min(1).describe('Auth ID'),
-        name: z.string().min(1).describe('Provider display name'),
-        gitlabUrl: z.string().min(1).describe('GitLab URL'),
-        gitlabInternalUrl: nullableString.describe('Internal GitLab URL'),
-    })
-        .strict(),
-    endpoint: '/gitlab.create',
-});
-const one = getTool({
-    name: 'dokploy_gitlab_one',
-    title: 'Get GitLab Provider',
-    description: 'Retrieve a GitLab provider integration by its ID.',
-    schema: z.object({ gitlabId: gitlabIdSchema }).strict(),
-    endpoint: '/gitlab.one',
-});
-const getGitlabRepositories = getTool({
-    name: 'dokploy_gitlab_get_gitlab_repositories',
-    title: 'List GitLab Repositories',
-    description: 'List repositories available through a Dokploy GitLab provider integration. Requires the GitLab provider ID.',
-    schema: z.object({ gitlabId: gitlabIdSchema }).strict(),
-    endpoint: '/gitlab.getGitlabRepositories',
-});
-const getGitlabBranches = getTool({
-    name: 'dokploy_gitlab_get_gitlab_branches',
-    title: 'List GitLab Branches',
-    description: 'List branches for a GitLab repository through Dokploy. Requires the owner and repository. Optionally pass the project numeric ID and GitLab provider ID.',
-    schema: z
-        .object({
-        id: z.number().optional().describe('GitLab project numeric ID'),
-        owner: z.string().describe('Repository owner'),
-        repo: z.string().describe('Repository name'),
-        gitlabId: z.string().optional().describe('GitLab provider ID'),
-    })
-        .strict(),
-    endpoint: '/gitlab.getGitlabBranches',
-});
-const gitlabProviders = getTool({
-    name: 'dokploy_gitlab_gitlab_providers',
-    title: 'List GitLab Providers',
-    description: 'List GitLab provider integrations configured in Dokploy.',
-    schema: z.object({}).strict(),
-    endpoint: '/gitlab.gitlabProviders',
-});
-const testConnection = postTool({
-    name: 'dokploy_gitlab_test_connection',
-    title: 'Test GitLab Connection',
-    description: 'Test a Dokploy GitLab provider integration. Requires the GitLab provider ID and optionally accepts the group name.',
-    schema: z
-        .object({
-        gitlabId: gitlabIdSchema,
-        groupName: z.string().optional().describe('GitLab group name'),
-    })
-        .strict(),
-    endpoint: '/gitlab.testConnection',
-});
-const update = postTool({
-    name: 'dokploy_gitlab_update',
-    title: 'Update GitLab Provider',
-    description: 'Update a Dokploy GitLab provider integration. Requires the GitLab provider ID, display name, GitLab URL, and linked Git provider ID. Optional OAuth and group fields may also be supplied.',
-    schema: z
-        .object({
-        applicationId: z.string().optional().describe('Application ID'),
-        secret: z.string().optional().describe('OAuth client secret'),
-        groupName: z.string().optional().describe('GitLab group name'),
-        redirectUri: z.string().optional().describe('OAuth redirect URI'),
-        name: z.string().min(1).describe('Provider display name'),
-        gitlabId: gitlabIdSchema,
-        gitlabUrl: z.string().min(1).describe('GitLab URL'),
-        gitProviderId: z.string().min(1).describe('Git provider ID'),
-        gitlabInternalUrl: nullableString.describe('Internal GitLab URL'),
-    })
-        .strict(),
-    endpoint: '/gitlab.update',
-});
-export const gitlabTools = [
-    create,
-    one,
-    getGitlabRepositories,
-    getGitlabBranches,
-    gitlabProviders,
-    testConnection,
-    update,
-];

package/dist/tools/index.d.ts

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

package/dist/tools/index.js

@@ -1,72 +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 { environmentTools } from './environment.js';
-import { gitProviderTools } from './git-provider.js';
-import { githubTools } from './github.js';
-import { gitlabTools } from './gitlab.js';
-import { mariadbTools } from './mariadb.js';
-import { mongoTools } from './mongo.js';
-import { mountsTools } from './mounts.js';
-import { mysqlTools } from './mysql.js';
-import { notificationTools } from './notification.js';
-import { patchTools } from './patch.js';
-import { portTools } from './port.js';
-import { postgresTools } from './postgres.js';
-import { previewDeploymentTools } from './preview-deployment.js';
-import { projectTools } from './project.js';
-import { redirectsTools } from './redirects.js';
-import { redisTools } from './redis.js';
-import { registryTools } from './registry.js';
-import { rollbackTools } from './rollback.js';
-import { scheduleTools } from './schedule.js';
-import { securityTools } from './security.js';
-import { serverTools } from './server.js';
-import { settingsTools } from './settings.js';
-import { sshKeyTools } from './ssh-key.js';
-import { userTools } from './user.js';
-import { volumeBackupsTools } from './volume-backups.js';
-export const allTools = [
-    ...projectTools,
-    ...environmentTools,
-    ...applicationTools,
-    ...composeTools,
-    ...domainTools,
-    ...patchTools,
-    ...postgresTools,
-    ...previewDeploymentTools,
-    ...mysqlTools,
-    ...mariadbTools,
-    ...mongoTools,
-    ...redisTools,
-    ...notificationTools,
-    ...rollbackTools,
-    ...scheduleTools,
-    ...volumeBackupsTools,
-    ...deploymentTools,
-    ...dockerTools,
-    ...certificatesTools,
-    ...registryTools,
-    ...destinationTools,
-    ...backupTools,
-    ...mountsTools,
-    ...portTools,
-    ...redirectsTools,
-    ...securityTools,
-    ...clusterTools,
-    ...settingsTools,
-    ...adminTools,
-    ...userTools,
-    ...serverTools,
-    ...sshKeyTools,
-    ...gitProviderTools,
-    ...githubTools,
-    ...gitlabTools,
-];

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).optional().describe('Root password for MariaDB'),
-    }),
-});

package/dist/tools/mongo.d.ts

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