@vibetools/dokploy-mcp 1.2.0 → 2.0.0

package/dist/tools/schedule.js

@@ -1,92 +0,0 @@
-import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-const nullableString = z.string().nullable().optional();
-const scheduleTypeSchema = z
-    .enum(['application', 'compose', 'server', 'dokploy-server'])
-    .describe('Schedule type');
-const shellTypeSchema = z.enum(['bash', 'sh']).describe('Shell type');
-const schedulePayload = z
-    .object({
-    scheduleId: z.string().optional().describe('Schedule ID'),
-    name: z.string().describe('Schedule name'),
-    cronExpression: z.string().describe('Cron expression'),
-    appName: z.string().optional().describe('App name'),
-    serviceName: nullableString.describe('Service name'),
-    shellType: shellTypeSchema.optional(),
-    scheduleType: scheduleTypeSchema.optional(),
-    command: z.string().describe('Command to execute'),
-    script: nullableString.describe('Inline script'),
-    applicationId: nullableString.describe('Application ID'),
-    composeId: nullableString.describe('Compose ID'),
-    serverId: nullableString.describe('Server ID'),
-    userId: nullableString.describe('User ID'),
-    enabled: z.boolean().optional().describe('Whether the schedule is enabled'),
-    timezone: nullableString.describe('Timezone'),
-    createdAt: z.string().optional().describe('Creation timestamp'),
-})
-    .strict();
-const list = getTool({
-    name: 'dokploy_schedule_list',
-    title: 'List Schedules',
-    description: 'List schedules in Dokploy for a specific entity ID and schedule type.',
-    schema: z
-        .object({
-        id: z.string().describe('Entity ID'),
-        scheduleType: scheduleTypeSchema,
-    })
-        .strict(),
-    endpoint: '/schedule.list',
-});
-const one = getTool({
-    name: 'dokploy_schedule_one',
-    title: 'Get Schedule',
-    description: 'Retrieve a Dokploy schedule by its ID.',
-    schema: z
-        .object({
-        scheduleId: z.string().describe('Schedule ID'),
-    })
-        .strict(),
-    endpoint: '/schedule.one',
-});
-const create = postTool({
-    name: 'dokploy_schedule_create',
-    title: 'Create Schedule',
-    description: 'Create a new schedule in Dokploy. Requires the schedule name, cron expression, and command.',
-    schema: schedulePayload,
-    endpoint: '/schedule.create',
-});
-const update = postTool({
-    name: 'dokploy_schedule_update',
-    title: 'Update Schedule',
-    description: 'Update an existing schedule in Dokploy. Requires the schedule ID together with the updated schedule payload.',
-    schema: schedulePayload
-        .extend({
-        scheduleId: z.string().min(1).describe('Schedule ID'),
-    })
-        .strict(),
-    endpoint: '/schedule.update',
-});
-const remove = postTool({
-    name: 'dokploy_schedule_delete',
-    title: 'Delete Schedule',
-    description: 'Delete a schedule from Dokploy. Requires the schedule ID. This is a destructive action.',
-    schema: z
-        .object({
-        scheduleId: z.string().describe('Schedule ID'),
-    })
-        .strict(),
-    endpoint: '/schedule.delete',
-    annotations: { destructiveHint: true },
-});
-const runManually = postTool({
-    name: 'dokploy_schedule_run_manually',
-    title: 'Run Schedule Manually',
-    description: 'Run a Dokploy schedule immediately. Requires the schedule ID.',
-    schema: z
-        .object({
-        scheduleId: z.string().min(1).describe('Schedule ID'),
-    })
-        .strict(),
-    endpoint: '/schedule.runManually',
-});
-export const scheduleTools = [list, one, create, update, remove, runManually];

package/dist/tools/security.d.ts

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

package/dist/tools/security.js

@@ -1,48 +0,0 @@
-import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-// ── helpers ──────────────────────────────────────────────────────────
-const securityId = z.string().min(1).describe('Unique security entry ID');
-// ── tools ────────────────────────────────────────────────────────────
-const one = getTool({
-    name: 'dokploy_security_one',
-    title: 'Get Security Entry',
-    description: 'Get details of a specific HTTP basic-auth security entry by its unique ID. Requires the securityId parameter. Returns the full security configuration including the associated application, username, and authentication settings.',
-    schema: z.object({ securityId }).strict(),
-    endpoint: '/security.one',
-});
-const create = postTool({
-    name: 'dokploy_security_create',
-    title: 'Create Security Entry',
-    description: 'Create a new HTTP basic-auth security entry to protect an application with username and password authentication. Requires the applicationId, username, and password parameters. Returns the newly created security entry with its assigned ID.',
-    schema: z
-        .object({
-        applicationId: z.string().min(1).describe('ID of the application to protect'),
-        username: z.string().min(1).describe('Username for basic-auth access'),
-        password: z.string().min(1).describe('Password for basic-auth access'),
-    })
-        .strict(),
-    endpoint: '/security.create',
-});
-const update = postTool({
-    name: 'dokploy_security_update',
-    title: 'Update Security Entry',
-    description: 'Update an existing HTTP basic-auth security entry by its ID. Requires the securityId and accepts optional username and password fields. Only provided fields will be updated; omitted fields remain unchanged. Returns the updated security entry.',
-    schema: z
-        .object({
-        securityId,
-        username: z.string().optional().describe('New username for basic-auth access'),
-        password: z.string().optional().describe('New password for basic-auth access'),
-    })
-        .strict(),
-    endpoint: '/security.update',
-});
-const deleteTool = postTool({
-    name: 'dokploy_security_delete',
-    title: 'Delete Security Entry',
-    description: 'Delete an HTTP basic-auth security entry permanently by its ID. This action is irreversible and will immediately remove authentication protection from the associated application. Requires the securityId parameter. Returns a confirmation of the deletion.',
-    schema: z.object({ securityId }).strict(),
-    endpoint: '/security.delete',
-    annotations: { destructiveHint: true },
-});
-// ── export ───────────────────────────────────────────────────────────
-export const securityTools = [one, create, update, deleteTool];

package/dist/tools/server.d.ts

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

package/dist/tools/server.js

@@ -1,192 +0,0 @@
-import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-const serverIdSchema = z.string().min(1).describe('The server ID');
-const metricsConfigSchema = z
-    .object({
-    server: z
-        .object({
-        refreshRate: z.number().min(2).describe('Refresh rate in seconds'),
-        port: z.number().min(1).describe('Monitoring port'),
-        token: z.string().describe('Monitoring token'),
-        urlCallback: z.string().url().describe('Callback URL'),
-        retentionDays: z.number().min(1).describe('Retention period in days'),
-        cronJob: z.string().min(1).describe('Cron expression'),
-        thresholds: z
-            .object({
-            cpu: z.number().min(0).describe('CPU threshold'),
-            memory: z.number().min(0).describe('Memory threshold'),
-        })
-            .strict(),
-    })
-        .strict(),
-    containers: z
-        .object({
-        refreshRate: z.number().min(2).describe('Container refresh rate in seconds'),
-        services: z
-            .object({
-            include: z.array(z.string()).optional().describe('Services to include'),
-            exclude: z.array(z.string()).optional().describe('Services to exclude'),
-        })
-            .strict(),
-    })
-        .strict(),
-})
-    .strict();
-const serverPayload = z
-    .object({
-    name: z.string().min(1).describe('Server name'),
-    description: z.string().nullable().describe('Server description'),
-    ipAddress: z.string().describe('Server IP address'),
-    port: z.number().describe('SSH port'),
-    username: z.string().describe('SSH username'),
-    sshKeyId: z.string().nullable().describe('SSH key ID'),
-    serverType: z.enum(['deploy', 'build']).describe('Server role'),
-})
-    .strict();
-const all = getTool({
-    name: 'dokploy_server_all',
-    title: 'List Servers',
-    description: 'List all Dokploy servers available to the current account. Returns deploy and build servers with their metadata.',
-    schema: z.object({}).strict(),
-    endpoint: '/server.all',
-});
-const one = getTool({
-    name: 'dokploy_server_one',
-    title: 'Get Server',
-    description: 'Retrieve detailed information about a Dokploy server by its ID. Returns connection settings, monitoring state, and security details.',
-    schema: z.object({ serverId: serverIdSchema }).strict(),
-    endpoint: '/server.one',
-});
-const count = getTool({
-    name: 'dokploy_server_count',
-    title: 'Count Servers',
-    description: 'Return the number of servers configured in Dokploy.',
-    schema: z.object({}).strict(),
-    endpoint: '/server.count',
-});
-const withSshKey = getTool({
-    name: 'dokploy_server_with_ssh_key',
-    title: 'List Servers with SSH Keys',
-    description: 'List Dokploy servers together with their linked SSH key information. Useful when selecting a server-key pair for operations.',
-    schema: z.object({}).strict(),
-    endpoint: '/server.withSSHKey',
-});
-const buildServers = getTool({
-    name: 'dokploy_server_build_servers',
-    title: 'List Build Servers',
-    description: 'List Dokploy servers configured specifically for build workloads.',
-    schema: z.object({}).strict(),
-    endpoint: '/server.buildServers',
-});
-const validate = getTool({
-    name: 'dokploy_server_validate',
-    title: 'Validate Server',
-    description: 'Validate the SSH connectivity and server configuration for a Dokploy server. Requires the server ID.',
-    schema: z.object({ serverId: serverIdSchema }).strict(),
-    endpoint: '/server.validate',
-});
-const security = getTool({
-    name: 'dokploy_server_security',
-    title: 'Get Server Security',
-    description: 'Retrieve the server security posture and checks for a Dokploy server. Requires the server ID.',
-    schema: z.object({ serverId: serverIdSchema }).strict(),
-    endpoint: '/server.security',
-});
-const publicIp = getTool({
-    name: 'dokploy_server_public_ip',
-    title: 'Get Public IP',
-    description: 'Get the public IP address detected by Dokploy for the current installation.',
-    schema: z.object({}).strict(),
-    endpoint: '/server.publicIp',
-});
-const getServerTime = getTool({
-    name: 'dokploy_server_get_server_time',
-    title: 'Get Server Time',
-    description: 'Get the current server time reported by Dokploy.',
-    schema: z.object({}).strict(),
-    endpoint: '/server.getServerTime',
-});
-const getServerMetrics = getTool({
-    name: 'dokploy_server_get_server_metrics',
-    title: 'Get Server Metrics',
-    description: 'Retrieve server monitoring metrics from Dokploy. Requires the monitoring URL, token, and number of data points.',
-    schema: z
-        .object({
-        url: z.string().describe('Monitoring URL'),
-        token: z.string().describe('Monitoring token'),
-        dataPoints: z.string().describe('Number of data points'),
-    })
-        .strict(),
-    endpoint: '/server.getServerMetrics',
-});
-const getDefaultCommand = getTool({
-    name: 'dokploy_server_get_default_command',
-    title: 'Get Default Server Command',
-    description: 'Get the default provisioning command for a Dokploy server. Requires the server ID.',
-    schema: z.object({ serverId: serverIdSchema }).strict(),
-    endpoint: '/server.getDefaultCommand',
-});
-const create = postTool({
-    name: 'dokploy_server_create',
-    title: 'Create Server',
-    description: 'Create a new Dokploy server. Requires connection details, server type, and the linked SSH key ID or null for an unmanaged key.',
-    schema: serverPayload,
-    endpoint: '/server.create',
-});
-const update = postTool({
-    name: 'dokploy_server_update',
-    title: 'Update Server',
-    description: 'Update an existing Dokploy server. Requires the server ID together with the current server connection details and role. Optionally provide a command override.',
-    schema: serverPayload
-        .extend({
-        serverId: serverIdSchema,
-        command: z.string().optional().describe('Optional command override'),
-    })
-        .strict(),
-    endpoint: '/server.update',
-});
-const remove = postTool({
-    name: 'dokploy_server_remove',
-    title: 'Remove Server',
-    description: 'Permanently remove a Dokploy server from the installation. Requires the server ID. This operation is destructive.',
-    schema: z.object({ serverId: serverIdSchema }).strict(),
-    endpoint: '/server.remove',
-    annotations: { destructiveHint: true },
-});
-const setup = postTool({
-    name: 'dokploy_server_setup',
-    title: 'Setup Server',
-    description: 'Run the Dokploy setup workflow on an existing server. Requires the server ID.',
-    schema: z.object({ serverId: serverIdSchema }).strict(),
-    endpoint: '/server.setup',
-});
-const setupMonitoring = postTool({
-    name: 'dokploy_server_setup_monitoring',
-    title: 'Setup Server Monitoring',
-    description: 'Configure monitoring for a Dokploy server. Requires the server ID and a complete monitoring configuration.',
-    schema: z
-        .object({
-        serverId: serverIdSchema,
-        metricsConfig: metricsConfigSchema.describe('Monitoring configuration'),
-    })
-        .strict(),
-    endpoint: '/server.setupMonitoring',
-});
-export const serverTools = [
-    all,
-    one,
-    count,
-    withSshKey,
-    buildServers,
-    validate,
-    security,
-    publicIp,
-    getServerTime,
-    getServerMetrics,
-    getDefaultCommand,
-    create,
-    update,
-    remove,
-    setup,
-    setupMonitoring,
-];

package/dist/tools/settings.d.ts

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