@vibetools/dokploy-mcp 0.5.0 → 1.2.0

package/dist/tools/patch.js

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const entityTypeSchema = z.enum(['application', 'compose']).describe('Entity type');
+const patchTypeSchema = z.enum(['create', 'update', 'delete']).describe('Patch type');
+const savePatchTypeSchema = z.enum(['create', 'update']).default('update').describe('Patch type');
+const nullableString = z.string().nullable().optional();
+const create = postTool({
+    name: 'dokploy_patch_create',
+    title: 'Create Patch',
+    description: 'Create a new patch record in Dokploy. Requires the file path and file content. Optionally associate the patch with an application or compose service.',
+    schema: z
+        .object({
+        filePath: z.string().min(1).describe('File path inside the repository'),
+        content: z.string().describe('File content'),
+        type: patchTypeSchema.optional(),
+        enabled: z.boolean().optional().describe('Whether the patch is enabled'),
+        applicationId: nullableString.describe('Application ID'),
+        composeId: nullableString.describe('Compose ID'),
+    })
+        .strict(),
+    endpoint: '/patch.create',
+});
+const one = getTool({
+    name: 'dokploy_patch_one',
+    title: 'Get Patch',
+    description: 'Retrieve a patch record by its ID.',
+    schema: z
+        .object({
+        patchId: z.string().min(1).describe('Patch ID'),
+    })
+        .strict(),
+    endpoint: '/patch.one',
+});
+const byEntityId = getTool({
+    name: 'dokploy_patch_by_entity_id',
+    title: 'List Patches by Entity',
+    description: 'List patches associated with a Dokploy application or compose service. Requires the entity ID and entity type.',
+    schema: z
+        .object({
+        id: z.string().describe('Entity ID'),
+        type: entityTypeSchema,
+    })
+        .strict(),
+    endpoint: '/patch.byEntityId',
+});
+const update = postTool({
+    name: 'dokploy_patch_update',
+    title: 'Update Patch',
+    description: 'Update an existing patch record in Dokploy. Requires the patch ID and optionally accepts updated type, file path, content, enablement state, and timestamps.',
+    schema: z
+        .object({
+        patchId: z.string().min(1).describe('Patch ID'),
+        type: patchTypeSchema.optional(),
+        filePath: z.string().min(1).optional().describe('File path inside the repository'),
+        enabled: z.boolean().optional().describe('Whether the patch is enabled'),
+        content: z.string().optional().describe('File content'),
+        createdAt: z.string().optional().describe('Creation timestamp'),
+        updatedAt: nullableString.describe('Update timestamp'),
+    })
+        .strict(),
+    endpoint: '/patch.update',
+});
+const remove = postTool({
+    name: 'dokploy_patch_delete',
+    title: 'Delete Patch',
+    description: 'Delete a patch record from Dokploy. Requires the patch ID. This is a destructive action.',
+    schema: z
+        .object({
+        patchId: z.string().min(1).describe('Patch ID'),
+    })
+        .strict(),
+    endpoint: '/patch.delete',
+    annotations: { destructiveHint: true },
+});
+const toggleEnabled = postTool({
+    name: 'dokploy_patch_toggle_enabled',
+    title: 'Toggle Patch',
+    description: 'Enable or disable a patch record in Dokploy. Requires the patch ID and the desired enabled state.',
+    schema: z
+        .object({
+        patchId: z.string().min(1).describe('Patch ID'),
+        enabled: z.boolean().describe('Whether the patch should be enabled'),
+    })
+        .strict(),
+    endpoint: '/patch.toggleEnabled',
+});
+const ensureRepo = postTool({
+    name: 'dokploy_patch_ensure_repo',
+    title: 'Ensure Patch Repository',
+    description: 'Ensure that the local patch repository exists for a Dokploy application or compose service. Requires the entity ID and entity type.',
+    schema: z
+        .object({
+        id: z.string().describe('Entity ID'),
+        type: entityTypeSchema,
+    })
+        .strict(),
+    endpoint: '/patch.ensureRepo',
+});
+const readRepoDirectories = getTool({
+    name: 'dokploy_patch_read_repo_directories',
+    title: 'Read Patch Repository Directories',
+    description: 'Read directory entries inside a patch repository. Requires the entity ID, entity type, and repository path.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        type: entityTypeSchema,
+        repoPath: z.string().describe('Repository path'),
+    })
+        .strict(),
+    endpoint: '/patch.readRepoDirectories',
+});
+const readRepoFile = getTool({
+    name: 'dokploy_patch_read_repo_file',
+    title: 'Read Patch Repository File',
+    description: 'Read a file from a patch repository. Requires the entity ID, entity type, and file path.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        type: entityTypeSchema,
+        filePath: z.string().describe('File path'),
+    })
+        .strict(),
+    endpoint: '/patch.readRepoFile',
+});
+const saveFileAsPatch = postTool({
+    name: 'dokploy_patch_save_file_as_patch',
+    title: 'Save File as Patch',
+    description: 'Create or update a patch record from file content. Requires the entity ID, entity type, file path, and content.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        type: entityTypeSchema,
+        filePath: z.string().describe('File path'),
+        content: z.string().describe('File content'),
+        patchType: savePatchTypeSchema.optional(),
+    })
+        .strict(),
+    endpoint: '/patch.saveFileAsPatch',
+});
+const markFileForDeletion = postTool({
+    name: 'dokploy_patch_mark_file_for_deletion',
+    title: 'Mark File for Deletion',
+    description: 'Mark a file for deletion through the Dokploy patch workflow. Requires the entity ID, entity type, and file path.',
+    schema: z
+        .object({
+        id: z.string().min(1).describe('Entity ID'),
+        type: entityTypeSchema,
+        filePath: z.string().describe('File path'),
+    })
+        .strict(),
+    endpoint: '/patch.markFileForDeletion',
+    annotations: { destructiveHint: true },
+});
+const cleanPatchRepos = postTool({
+    name: 'dokploy_patch_clean_patch_repos',
+    title: 'Clean Patch Repositories',
+    description: 'Clean Dokploy patch repositories. Optionally scope the cleanup to a specific server.',
+    schema: z
+        .object({
+        serverId: z.string().optional().describe('Optional server ID'),
+    })
+        .strict(),
+    endpoint: '/patch.cleanPatchRepos',
+    annotations: { destructiveHint: true },
+});
+export const patchTools = [
+    create,
+    one,
+    byEntityId,
+    update,
+    remove,
+    toggleEnabled,
+    ensureRepo,
+    readRepoDirectories,
+    readRepoFile,
+    saveFileAsPatch,
+    markFileForDeletion,
+    cleanPatchRepos,
+];

package/dist/tools/postgres.d.ts

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

package/dist/tools/postgres.js

@@ -1,169 +1,13 @@
 import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-// ── helpers ──────────────────────────────────────────────────────────
-const pgId = z.string().min(1).describe('Unique Postgres database ID');
-const DB = 'postgres';
-// ── tools ────────────────────────────────────────────────────────────
-const one = getTool({
-    name: `dokploy_${DB}_one`,
-    title: 'Get Postgres Details',
-    description: 'Retrieve detailed information about a specific Postgres database managed by Dokploy. Returns the full configuration including connection settings, resource limits, environment variables, and current status. Requires the unique Postgres database ID.',
-    schema: z.object({ postgresId: pgId }).strict(),
-    endpoint: `${DB}.one`,
-});
-const create = postTool({
-    name: `dokploy_${DB}_create`,
-    title: 'Create Postgres Database',
-    description: 'Create a new Postgres database instance inside a Dokploy project. Requires a display name, app-level identifier, database name, user credentials, and the target project ID. Optionally specify a Docker image, description, or remote server. Returns the newly created database record.',
-    schema: z
-        .object({
-        name: z.string().min(1).describe('Display name for the database'),
-        appName: z.string().min(1).describe('Unique app-level identifier'),
+import { createDatabaseTools } from './_database.js';
+export const postgresTools = createDatabaseTools({
+    type: 'postgres',
+    idField: 'postgresId',
+    displayName: 'Postgres',
+    defaultImage: 'postgres:18',
+    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'),
-        projectId: z.string().min(1).describe('Project ID to create the database in'),
-        dockerImage: z.string().optional().describe('Docker image (default: postgres:15)'),
-        description: z.string().nullable().optional().describe('Optional description'),
-        serverId: z.string().nullable().optional().describe('Target server ID (null for local)'),
-    })
-        .strict(),
-    endpoint: `${DB}.create`,
-});
-const update = postTool({
-    name: `dokploy_${DB}_update`,
-    title: 'Update Postgres Database',
-    description: 'Update the configuration of an existing Postgres database in Dokploy. Supports modifying the display name, Docker image, resource limits (CPU and memory), custom start command, environment variables, and external port. Requires the Postgres database ID. Only the provided fields are updated.',
-    schema: z
-        .object({
-        postgresId: pgId,
-        name: z.string().min(1).optional().describe('Display name'),
-        appName: z.string().min(1).optional().describe('App-level identifier'),
-        description: z.string().nullable().optional().describe('Description'),
-        dockerImage: z.string().optional().describe('Docker image'),
-        memoryReservation: z.number().nullable().optional().describe('Memory reservation in MB'),
-        memoryLimit: z.number().nullable().optional().describe('Memory limit in MB'),
-        cpuReservation: z.number().nullable().optional().describe('CPU reservation'),
-        cpuLimit: z.number().nullable().optional().describe('CPU limit'),
-        command: z.string().nullable().optional().describe('Custom start command'),
-        env: z.string().nullable().optional().describe('Environment variables'),
-        externalPort: z.number().nullable().optional().describe('External port'),
-    })
-        .strict(),
-    endpoint: `${DB}.update`,
-});
-const remove = postTool({
-    name: `dokploy_${DB}_remove`,
-    title: 'Remove Postgres Database',
-    description: 'Permanently delete a Postgres database from Dokploy. This action removes the database container, its data, and all associated configuration. Requires the Postgres database ID. This operation is destructive and cannot be undone.',
-    schema: z.object({ postgresId: pgId }).strict(),
-    endpoint: `${DB}.remove`,
-    annotations: { destructiveHint: true },
-});
-const move = postTool({
-    name: `dokploy_${DB}_move`,
-    title: 'Move Postgres Database',
-    description: 'Move a Postgres database from its current project to a different project within Dokploy. Requires the Postgres database ID and the destination project ID. The database configuration and data are preserved during the move.',
-    schema: z
-        .object({
-        postgresId: pgId,
-        targetProjectId: z.string().min(1).describe('Destination project ID'),
-    })
-        .strict(),
-    endpoint: `${DB}.move`,
-});
-const deploy = postTool({
-    name: `dokploy_${DB}_deploy`,
-    title: 'Deploy Postgres Database',
-    description: 'Deploy a Postgres database container in Dokploy. Triggers the build and start process for the specified database. Requires the Postgres database ID. Returns the deployment status.',
-    schema: z.object({ postgresId: pgId }).strict(),
-    endpoint: `${DB}.deploy`,
-});
-const start = postTool({
-    name: `dokploy_${DB}_start`,
-    title: 'Start Postgres Database',
-    description: 'Start a previously stopped Postgres database container in Dokploy. The database must already be deployed. Requires the Postgres database ID. Returns the updated status after starting.',
-    schema: z.object({ postgresId: pgId }).strict(),
-    endpoint: `${DB}.start`,
-});
-const stop = postTool({
-    name: `dokploy_${DB}_stop`,
-    title: 'Stop Postgres Database',
-    description: 'Stop a running Postgres database container in Dokploy. The database data is preserved but the container will no longer accept connections. Requires the Postgres database ID. This is a destructive action as it interrupts active connections.',
-    schema: z.object({ postgresId: pgId }).strict(),
-    endpoint: `${DB}.stop`,
-    annotations: { destructiveHint: true },
-});
-const reload = postTool({
-    name: `dokploy_${DB}_reload`,
-    title: 'Reload Postgres Database',
-    description: 'Reload the Postgres database container in Dokploy without a full restart. Applies configuration changes that do not require a rebuild. Requires the Postgres database ID and the app-level identifier. Returns the reload status.',
-    schema: z
-        .object({
-        postgresId: pgId,
-        appName: z.string().min(1).describe('App-level identifier'),
-    })
-        .strict(),
-    endpoint: `${DB}.reload`,
-});
-const rebuild = postTool({
-    name: `dokploy_${DB}_rebuild`,
-    title: 'Rebuild Postgres Database',
-    description: 'Rebuild the Postgres database container from scratch in Dokploy. This tears down the existing container and recreates it with the current configuration. Requires the Postgres database ID. Useful after changing the Docker image or when the container is in a broken state.',
-    schema: z.object({ postgresId: pgId }).strict(),
-    endpoint: `${DB}.rebuild`,
-});
-const changeStatus = postTool({
-    name: `dokploy_${DB}_change_status`,
-    title: 'Change Postgres Status',
-    description: 'Manually set the application status of a Postgres database in Dokploy. Accepts one of: idle, running, done, or error. Requires the Postgres database ID and the new status value. Useful for correcting a stale or incorrect status.',
-    schema: z
-        .object({
-        postgresId: pgId,
-        applicationStatus: z
-            .enum(['idle', 'running', 'done', 'error'])
-            .describe('New application status'),
-    })
-        .strict(),
-    endpoint: `${DB}.changeStatus`,
-});
-const saveExternalPort = postTool({
-    name: `dokploy_${DB}_save_external_port`,
-    title: 'Save Postgres External Port',
-    description: 'Set or clear the external port mapping for a Postgres database in Dokploy. When set, the database is accessible from outside the Docker network on the specified port. Pass null to remove the external port. Requires the Postgres database ID.',
-    schema: z
-        .object({
-        postgresId: pgId,
-        externalPort: z.number().nullable().describe('External port number (null to remove)'),
-    })
-        .strict(),
-    endpoint: `${DB}.saveExternalPort`,
-});
-const saveEnvironment = postTool({
-    name: `dokploy_${DB}_save_environment`,
-    title: 'Save Postgres Environment',
-    description: 'Overwrite the environment variables for a Postgres database in Dokploy. Replaces all existing environment variables with the provided value. Pass the variables as a single string (one per line, KEY=VALUE format). Requires the Postgres database ID.',
-    schema: z
-        .object({
-        postgresId: pgId,
-        env: z.string().nullable().optional().describe('Environment variables as a string'),
-    })
-        .strict(),
-    endpoint: `${DB}.saveEnvironment`,
+    }),
 });
-// ── export ───────────────────────────────────────────────────────────
-export const postgresTools = [
-    one,
-    create,
-    update,
-    remove,
-    move,
-    deploy,
-    start,
-    stop,
-    reload,
-    rebuild,
-    changeStatus,
-    saveExternalPort,
-    saveEnvironment,
-];

package/dist/tools/preview-deployment.d.ts

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

package/dist/tools/preview-deployment.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { getTool, postTool } from './_factory.js';
+const all = getTool({
+    name: 'dokploy_preview_deployment_all',
+    title: 'List Preview Deployments',
+    description: 'List preview deployments for a Dokploy application. Requires the application ID.',
+    schema: z
+        .object({
+        applicationId: z.string().min(1).describe('Application ID'),
+    })
+        .strict(),
+    endpoint: '/previewDeployment.all',
+});
+const one = getTool({
+    name: 'dokploy_preview_deployment_one',
+    title: 'Get Preview Deployment',
+    description: 'Retrieve a preview deployment by its ID.',
+    schema: z
+        .object({
+        previewDeploymentId: z.string().describe('Preview deployment ID'),
+    })
+        .strict(),
+    endpoint: '/previewDeployment.one',
+});
+const remove = postTool({
+    name: 'dokploy_preview_deployment_delete',
+    title: 'Delete Preview Deployment',
+    description: 'Delete a preview deployment in Dokploy. Requires the preview deployment ID. This is a destructive action.',
+    schema: z
+        .object({
+        previewDeploymentId: z.string().describe('Preview deployment ID'),
+    })
+        .strict(),
+    endpoint: '/previewDeployment.delete',
+    annotations: { destructiveHint: true },
+});
+const redeploy = postTool({
+    name: 'dokploy_preview_deployment_redeploy',
+    title: 'Redeploy Preview Deployment',
+    description: 'Redeploy a preview deployment in Dokploy. Requires the preview deployment ID and optionally accepts a title and description.',
+    schema: z
+        .object({
+        previewDeploymentId: z.string().describe('Preview deployment ID'),
+        title: z.string().optional().describe('Optional deployment title'),
+        description: z.string().optional().describe('Optional deployment description'),
+    })
+        .strict(),
+    endpoint: '/previewDeployment.redeploy',
+});
+export const previewDeploymentTools = [all, one, remove, redeploy];

package/dist/tools/project.js

@@ -8,6 +8,13 @@ const all = getTool({
     schema: z.object({}).strict(),
     endpoint: '/project.all',
 });
+const allForPermissions = getTool({
+    name: 'dokploy_project_all_for_permissions',
+    title: 'List Projects for Permissions',
+    description: 'List projects in the format used by Dokploy permission assignment workflows.',
+    schema: z.object({}).strict(),
+    endpoint: '/project.allForPermissions',
+});
 const one = getTool({
     name: 'dokploy_project_one',
     title: 'Get Project Details',
@@ -90,5 +97,29 @@ const remove = postTool({
     endpoint: '/project.remove',
     annotations: { destructiveHint: true },
 });
+const search = getTool({
+    name: 'dokploy_project_search',
+    title: 'Search Projects',
+    description: 'Search Dokploy projects 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('Project name'),
+        description: z.string().optional().describe('Project description'),
+        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: '/project.search',
+});
 // ── export ───────────────────────────────────────────────────────────
-export const projectTools = [all, one, create, update, duplicate, remove];
+export const projectTools = [
+    all,
+    allForPermissions,
+    one,
+    create,
+    update,
+    duplicate,
+    remove,
+    search,
+];

package/dist/tools/redis.d.ts

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

package/dist/tools/redis.js

@@ -1,167 +1,11 @@
 import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-// ── helpers ──────────────────────────────────────────────────────────
-const rdId = z.string().min(1).describe('Unique Redis database ID');
-const DB = 'redis';
-// ── tools ────────────────────────────────────────────────────────────
-const one = getTool({
-    name: `dokploy_${DB}_one`,
-    title: 'Get Redis Details',
-    description: 'Retrieve the full configuration and status details of a Redis database managed by Dokploy. Requires the unique Redis database ID. Returns all metadata including name, image, resource limits, environment variables, and current application status.',
-    schema: z.object({ redisId: rdId }).strict(),
-    endpoint: `${DB}.one`,
-});
-const create = postTool({
-    name: `dokploy_${DB}_create`,
-    title: 'Create Redis Database',
-    description: 'Create a new Redis database instance inside a Dokploy project. Requires a display name, app-level identifier, database password, and the target project ID. Optionally specify a Docker image, description, or remote server. Returns the newly created database record.',
-    schema: z
-        .object({
-        name: z.string().min(1).describe('Display name for the database'),
-        appName: z.string().min(1).describe('Unique app-level identifier'),
+import { createDatabaseTools } from './_database.js';
+export const redisTools = createDatabaseTools({
+    type: 'redis',
+    idField: 'redisId',
+    displayName: 'Redis',
+    defaultImage: 'redis:8',
+    createFields: z.object({
         databasePassword: z.string().min(1).describe('Database password'),
-        projectId: z.string().min(1).describe('Project ID to create the database in'),
-        dockerImage: z.string().optional().describe('Docker image (default: redis:7)'),
-        description: z.string().nullable().optional().describe('Optional description'),
-        serverId: z.string().nullable().optional().describe('Target server ID (null for local)'),
-    })
-        .strict(),
-    endpoint: `${DB}.create`,
-});
-const update = postTool({
-    name: `dokploy_${DB}_update`,
-    title: 'Update Redis Database',
-    description: 'Update the configuration of an existing Redis database in Dokploy. Requires the Redis database ID and accepts optional fields such as name, Docker image, resource limits (memory and CPU), custom start command, environment variables, and external port. Returns the updated database configuration.',
-    schema: z
-        .object({
-        redisId: rdId,
-        name: z.string().min(1).optional().describe('Display name'),
-        appName: z.string().min(1).optional().describe('App-level identifier'),
-        description: z.string().nullable().optional().describe('Description'),
-        dockerImage: z.string().optional().describe('Docker image'),
-        memoryReservation: z.number().nullable().optional().describe('Memory reservation in MB'),
-        memoryLimit: z.number().nullable().optional().describe('Memory limit in MB'),
-        cpuReservation: z.number().nullable().optional().describe('CPU reservation'),
-        cpuLimit: z.number().nullable().optional().describe('CPU limit'),
-        command: z.string().nullable().optional().describe('Custom start command'),
-        env: z.string().nullable().optional().describe('Environment variables'),
-        externalPort: z.number().nullable().optional().describe('External port'),
-    })
-        .strict(),
-    endpoint: `${DB}.update`,
-});
-const remove = postTool({
-    name: `dokploy_${DB}_remove`,
-    title: 'Remove Redis Database',
-    description: 'Permanently delete a Redis database from Dokploy. Requires the Redis database ID. This is a destructive operation that removes the container, all associated data, and configuration. Returns the operation status confirming deletion.',
-    schema: z.object({ redisId: rdId }).strict(),
-    endpoint: `${DB}.remove`,
-    annotations: { destructiveHint: true },
-});
-const move = postTool({
-    name: `dokploy_${DB}_move`,
-    title: 'Move Redis Database',
-    description: 'Move a Redis database from its current project to a different project within Dokploy. Requires the Redis database ID and the destination project ID. The database configuration and data remain intact during the move. Returns the operation status.',
-    schema: z
-        .object({
-        redisId: rdId,
-        targetProjectId: z.string().min(1).describe('Destination project ID'),
-    })
-        .strict(),
-    endpoint: `${DB}.move`,
-});
-const deploy = postTool({
-    name: `dokploy_${DB}_deploy`,
-    title: 'Deploy Redis Database',
-    description: 'Deploy a Redis database in Dokploy, pulling the configured Docker image and starting the container. Requires the Redis database ID. This triggers a full deployment lifecycle including image pull, container creation, and startup. Returns the deployment operation status.',
-    schema: z.object({ redisId: rdId }).strict(),
-    endpoint: `${DB}.deploy`,
-});
-const start = postTool({
-    name: `dokploy_${DB}_start`,
-    title: 'Start Redis Database',
-    description: 'Start a previously stopped Redis database container in Dokploy. Requires the Redis database ID. The container will resume with its existing data and configuration. Returns the operation status.',
-    schema: z.object({ redisId: rdId }).strict(),
-    endpoint: `${DB}.start`,
-});
-const stop = postTool({
-    name: `dokploy_${DB}_stop`,
-    title: 'Stop Redis Database',
-    description: 'Stop a currently running Redis database container in Dokploy. Requires the Redis database ID. The container will be gracefully stopped but its data and configuration are preserved for future restarts. Returns the operation status.',
-    schema: z.object({ redisId: rdId }).strict(),
-    endpoint: `${DB}.stop`,
-    annotations: { destructiveHint: true },
-});
-const reload = postTool({
-    name: `dokploy_${DB}_reload`,
-    title: 'Reload Redis Database',
-    description: 'Reload the Redis database container in Dokploy without performing a full rebuild. Requires the Redis database ID and the app-level identifier. This restarts the container with its current configuration. Returns the operation status.',
-    schema: z
-        .object({
-        redisId: rdId,
-        appName: z.string().min(1).describe('App-level identifier'),
-    })
-        .strict(),
-    endpoint: `${DB}.reload`,
-});
-const rebuild = postTool({
-    name: `dokploy_${DB}_rebuild`,
-    title: 'Rebuild Redis Database',
-    description: 'Rebuild the Redis database container from scratch in Dokploy. Requires the Redis database ID. This tears down the existing container and recreates it using the current configuration, which is useful when the container state has become inconsistent. Returns the operation status.',
-    schema: z.object({ redisId: rdId }).strict(),
-    endpoint: `${DB}.rebuild`,
-});
-const changeStatus = postTool({
-    name: `dokploy_${DB}_change_status`,
-    title: 'Change Redis Status',
-    description: 'Manually set the application status of a Redis database in Dokploy. Requires the Redis database ID and the desired status (idle, running, done, or error). This is typically used for administrative overrides when the reported status does not match reality. Returns the updated status.',
-    schema: z
-        .object({
-        redisId: rdId,
-        applicationStatus: z
-            .enum(['idle', 'running', 'done', 'error'])
-            .describe('New application status'),
-    })
-        .strict(),
-    endpoint: `${DB}.changeStatus`,
-});
-const saveExternalPort = postTool({
-    name: `dokploy_${DB}_save_external_port`,
-    title: 'Save Redis External Port',
-    description: 'Set or clear the external port mapping for a Redis database in Dokploy. Requires the Redis database ID and the desired external port number, or null to remove the external port mapping. This controls whether the database is accessible from outside the Docker network. Returns the operation status.',
-    schema: z
-        .object({
-        redisId: rdId,
-        externalPort: z.number().nullable().describe('External port number (null to remove)'),
-    })
-        .strict(),
-    endpoint: `${DB}.saveExternalPort`,
-});
-const saveEnvironment = postTool({
-    name: `dokploy_${DB}_save_environment`,
-    title: 'Save Redis Environment',
-    description: 'Overwrite the environment variables for a Redis database in Dokploy. Requires the Redis database ID and the environment variables as a string. This replaces all existing environment variables with the provided values. Returns the operation status.',
-    schema: z
-        .object({
-        redisId: rdId,
-        env: z.string().nullable().optional().describe('Environment variables as a string'),
-    })
-        .strict(),
-    endpoint: `${DB}.saveEnvironment`,
+    }),
 });
-// ── export ───────────────────────────────────────────────────────────
-export const redisTools = [
-    one,
-    create,
-    update,
-    remove,
-    move,
-    deploy,
-    start,
-    stop,
-    reload,
-    rebuild,
-    changeStatus,
-    saveExternalPort,
-    saveEnvironment,
-];

package/dist/tools/rollback.d.ts

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