@vibetools/dokploy-mcp 0.5.0 → 1.2.0

package/dist/tools/rollback.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { postTool } from './_factory.js';
+const rollbackIdSchema = z.string().min(1).describe('Rollback ID');
+const rollback = postTool({
+    name: 'dokploy_rollback_rollback',
+    title: 'Execute Rollback',
+    description: 'Execute a rollback in Dokploy. Requires the rollback ID and triggers a rollback to the associated deployment target.',
+    schema: z
+        .object({
+        rollbackId: rollbackIdSchema,
+    })
+        .strict(),
+    endpoint: '/rollback.rollback',
+    annotations: { destructiveHint: true },
+});
+const remove = postTool({
+    name: 'dokploy_rollback_delete',
+    title: 'Delete Rollback Record',
+    description: 'Delete a rollback record from Dokploy. Requires the rollback ID. This is a destructive action.',
+    schema: z
+        .object({
+        rollbackId: rollbackIdSchema,
+    })
+        .strict(),
+    endpoint: '/rollback.delete',
+    annotations: { destructiveHint: true },
+});
+export const rollbackTools = [rollback, remove];

package/dist/tools/schedule.d.ts

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

package/dist/tools/schedule.js

@@ -0,0 +1,92 @@
+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/server.d.ts

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

package/dist/tools/server.js

@@ -0,0 +1,192 @@
+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.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { getTool, postTool } from './_factory.js';
 // ── tools ────────────────────────────────────────────────────────────
+const optionalServerId = z.string().optional().describe('Optional server ID');
+const protocolSchema = z.enum(['tcp', 'udp', 'sctp']).describe('Port protocol');
 const reloadServer = postTool({
     name: 'dokploy_settings_reload_server',
     title: 'Reload Server',
@@ -228,6 +230,231 @@ const updateTraefikFile = postTool({
         .strict(),
     endpoint: '/settings.updateTraefikFile',
 });
+const readTraefikEnv = getTool({
+    name: 'dokploy_settings_read_traefik_env',
+    title: 'Read Traefik Environment',
+    description: 'Read the Traefik environment configuration from Dokploy. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.readTraefikEnv',
+});
+const writeTraefikEnv = postTool({
+    name: 'dokploy_settings_write_traefik_env',
+    title: 'Write Traefik Environment',
+    description: 'Write the Traefik environment configuration in Dokploy. Requires the environment content and optionally accepts a server ID.',
+    schema: z
+        .object({
+        env: z.string().describe('Traefik environment content'),
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.writeTraefikEnv',
+});
+const updateTraefikPorts = postTool({
+    name: 'dokploy_settings_update_traefik_ports',
+    title: 'Update Traefik Ports',
+    description: 'Update additional Traefik ports in Dokploy. Requires the list of additional ports and optionally accepts a server ID.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+        additionalPorts: z
+            .array(z
+            .object({
+            targetPort: z.number().describe('Target port'),
+            publishedPort: z.number().describe('Published port'),
+            protocol: protocolSchema,
+        })
+            .strict())
+            .describe('Additional Traefik ports'),
+    })
+        .strict(),
+    endpoint: '/settings.updateTraefikPorts',
+});
+const getTraefikPorts = getTool({
+    name: 'dokploy_settings_get_traefik_ports',
+    title: 'Get Traefik Ports',
+    description: 'Get Traefik ports configured in Dokploy. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.getTraefikPorts',
+});
+const haveTraefikDashboardPortEnabled = getTool({
+    name: 'dokploy_settings_have_traefik_dashboard_port_enabled',
+    title: 'Check Traefik Dashboard Port',
+    description: 'Check whether the Traefik dashboard port is enabled in Dokploy. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.haveTraefikDashboardPortEnabled',
+});
+const toggleDashboard = postTool({
+    name: 'dokploy_settings_toggle_dashboard',
+    title: 'Toggle Traefik Dashboard',
+    description: 'Enable or disable the Traefik dashboard in Dokploy. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        enableDashboard: z.boolean().optional().describe('Whether to enable the dashboard'),
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.toggleDashboard',
+});
+const health = getTool({
+    name: 'dokploy_settings_health',
+    title: 'Get Dokploy Health',
+    description: 'Get the current health status of the Dokploy installation.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.health',
+});
+const getIp = getTool({
+    name: 'dokploy_settings_get_ip',
+    title: 'Get Server IP',
+    description: 'Get the server IP address known to Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getIp',
+});
+const updateServerIp = postTool({
+    name: 'dokploy_settings_update_server_ip',
+    title: 'Update Server IP',
+    description: 'Update the server IP address used by Dokploy.',
+    schema: z
+        .object({
+        serverIp: z.string().describe('Server IP address'),
+    })
+        .strict(),
+    endpoint: '/settings.updateServerIp',
+});
+const getWebServerSettings = getTool({
+    name: 'dokploy_settings_get_web_server_settings',
+    title: 'Get Web Server Settings',
+    description: 'Get web server settings configured in Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getWebServerSettings',
+});
+const getUpdateData = postTool({
+    name: 'dokploy_settings_get_update_data',
+    title: 'Get Update Data',
+    description: 'Get update metadata for the current Dokploy installation.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getUpdateData',
+});
+const getReleaseTag = getTool({
+    name: 'dokploy_settings_get_release_tag',
+    title: 'Get Release Tag',
+    description: 'Get the latest Dokploy release tag visible to the current installation.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getReleaseTag',
+});
+const cleanRedis = postTool({
+    name: 'dokploy_settings_clean_redis',
+    title: 'Clean Redis',
+    description: 'Clean Dokploy Redis data. This is a destructive maintenance action.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanRedis',
+    annotations: { destructiveHint: true },
+});
+const reloadRedis = postTool({
+    name: 'dokploy_settings_reload_redis',
+    title: 'Reload Redis',
+    description: 'Reload Dokploy Redis.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.reloadRedis',
+});
+const cleanAllDeploymentQueue = postTool({
+    name: 'dokploy_settings_clean_all_deployment_queue',
+    title: 'Clean Deployment Queue',
+    description: 'Clear the Dokploy deployment queue. This is a destructive maintenance action.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.cleanAllDeploymentQueue',
+    annotations: { destructiveHint: true },
+});
+const updateLogCleanup = postTool({
+    name: 'dokploy_settings_update_log_cleanup',
+    title: 'Update Log Cleanup Schedule',
+    description: 'Update the Dokploy log cleanup schedule.',
+    schema: z
+        .object({
+        cronExpression: z.string().nullable().describe('Cron expression for log cleanup'),
+    })
+        .strict(),
+    endpoint: '/settings.updateLogCleanup',
+});
+const getLogCleanupStatus = getTool({
+    name: 'dokploy_settings_get_log_cleanup_status',
+    title: 'Get Log Cleanup Status',
+    description: 'Get the current Dokploy log cleanup configuration and status.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getLogCleanupStatus',
+});
+const setupGpu = postTool({
+    name: 'dokploy_settings_setup_gpu',
+    title: 'Setup GPU',
+    description: 'Run Dokploy GPU setup. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.setupGPU',
+});
+const checkGpuStatus = getTool({
+    name: 'dokploy_settings_check_gpu_status',
+    title: 'Check GPU Status',
+    description: 'Check Dokploy GPU status. Optionally scope the request to a specific server.',
+    schema: z
+        .object({
+        serverId: optionalServerId,
+    })
+        .strict(),
+    endpoint: '/settings.checkGPUStatus',
+});
+const isCloud = getTool({
+    name: 'dokploy_settings_is_cloud',
+    title: 'Check Cloud Mode',
+    description: 'Check whether the current Dokploy installation runs in cloud mode.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.isCloud',
+});
+const isUserSubscribed = getTool({
+    name: 'dokploy_settings_is_user_subscribed',
+    title: 'Check Subscription Status',
+    description: 'Check whether the current Dokploy user has an active subscription.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.isUserSubscribed',
+});
+const haveActivateRequests = getTool({
+    name: 'dokploy_settings_have_activate_requests',
+    title: 'Check Request Logging',
+    description: 'Check whether request handling features are enabled in Dokploy.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.haveActivateRequests',
+});
+const toggleRequests = postTool({
+    name: 'dokploy_settings_toggle_requests',
+    title: 'Toggle Requests',
+    description: 'Enable or disable request handling features in Dokploy.',
+    schema: z
+        .object({
+        enable: z.boolean().describe('Whether to enable requests'),
+    })
+        .strict(),
+    endpoint: '/settings.toggleRequests',
+});
+const getDokployCloudIps = getTool({
+    name: 'dokploy_settings_get_dokploy_cloud_ips',
+    title: 'Get Dokploy Cloud IPs',
+    description: 'Get Dokploy Cloud IP ranges.',
+    schema: z.object({}).strict(),
+    endpoint: '/settings.getDokployCloudIps',
+});
 // ── export ───────────────────────────────────────────────────────────
 export const settingsTools = [
     reloadServer,
@@ -255,4 +482,28 @@ export const settingsTools = [
     getOpenApiDocument,
     readTraefikFile,
     updateTraefikFile,
+    readTraefikEnv,
+    writeTraefikEnv,
+    updateTraefikPorts,
+    getTraefikPorts,
+    haveTraefikDashboardPortEnabled,
+    toggleDashboard,
+    health,
+    getIp,
+    updateServerIp,
+    getWebServerSettings,
+    getUpdateData,
+    getReleaseTag,
+    cleanRedis,
+    reloadRedis,
+    cleanAllDeploymentQueue,
+    updateLogCleanup,
+    getLogCleanupStatus,
+    setupGpu,
+    checkGpuStatus,
+    isCloud,
+    isUserSubscribed,
+    haveActivateRequests,
+    toggleRequests,
+    getDokployCloudIps,
 ];

package/dist/tools/ssh-key.d.ts

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

package/dist/tools/ssh-key.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const nullableString = z.string().nullable().optional();
+const all = getTool({
+    name: 'dokploy_ssh_key_all',
+    title: 'List SSH Keys',
+    description: 'List all SSH keys available in Dokploy. Returns stored keys together with their metadata and organization context.',
+    schema: z.object({}).strict(),
+    endpoint: '/sshKey.all',
+});
+const create = postTool({
+    name: 'dokploy_ssh_key_create',
+    title: 'Create SSH Key',
+    description: 'Create a new SSH key record in Dokploy. Requires the key pair and a name. Optionally set a description and organization ID.',
+    schema: z
+        .object({
+        name: z.string().min(1).describe('SSH key name'),
+        description: z.string().nullable().optional().describe('SSH key description'),
+        privateKey: z.string().describe('Private key content'),
+        publicKey: z.string().describe('Public key content'),
+        organizationId: z.string().optional().describe('Organization ID'),
+    })
+        .strict(),
+    endpoint: '/sshKey.create',
+});
+const generate = postTool({
+    name: 'dokploy_ssh_key_generate',
+    title: 'Generate SSH Key Pair',
+    description: 'Generate a new SSH key pair in Dokploy. Optionally specify the key type; supported values are rsa and ed25519.',
+    schema: z
+        .object({
+        type: z.enum(['rsa', 'ed25519']).optional().describe('SSH key type'),
+    })
+        .strict(),
+    endpoint: '/sshKey.generate',
+});
+const one = getTool({
+    name: 'dokploy_ssh_key_one',
+    title: 'Get SSH Key',
+    description: 'Retrieve detailed information about a Dokploy SSH key by its ID.',
+    schema: z
+        .object({
+        sshKeyId: z.string().min(1).describe('SSH key ID'),
+    })
+        .strict(),
+    endpoint: '/sshKey.one',
+});
+const remove = postTool({
+    name: 'dokploy_ssh_key_remove',
+    title: 'Remove SSH Key',
+    description: 'Permanently remove an SSH key from Dokploy. Requires the SSH key ID. This is a destructive action.',
+    schema: z
+        .object({
+        sshKeyId: z.string().min(1).describe('SSH key ID'),
+    })
+        .strict(),
+    endpoint: '/sshKey.remove',
+    annotations: { destructiveHint: true },
+});
+const update = postTool({
+    name: 'dokploy_ssh_key_update',
+    title: 'Update SSH Key',
+    description: 'Update metadata for a Dokploy SSH key. Requires the SSH key ID and accepts optional name, description, and last-used timestamp changes.',
+    schema: z
+        .object({
+        sshKeyId: z.string().min(1).describe('SSH key ID'),
+        name: z.string().min(1).optional().describe('SSH key name'),
+        description: nullableString.describe('SSH key description'),
+        lastUsedAt: nullableString.describe('Last used timestamp'),
+    })
+        .strict(),
+    endpoint: '/sshKey.update',
+});
+export const sshKeyTools = [all, create, generate, one, remove, update];