@vibetools/dokploy-mcp 0.4.0 → 1.0.0

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:7',
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibetools/dokploy-mcp",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "MCP Server for the Dokploy API - complete coverage of all endpoints",
   "type": "module",
   "exports": {
@@ -19,6 +19,9 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --noEmit",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
@@ -34,7 +37,9 @@
   "devDependencies": {
     "@biomejs/biome": "^2.4.4",
     "@types/node": "^22.19.11",
-    "typescript": "^5.9.3"
+    "@vitest/coverage-v8": "^4.0.18",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   },
   "engines": {
     "node": ">=22.0.0"

package/dist/tools/auth.d.ts

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

package/dist/tools/auth.js

@@ -1,150 +0,0 @@
-import { z } from 'zod';
-import { getTool, postTool } from './_factory.js';
-// ── tools ────────────────────────────────────────────────────────────
-const createAdmin = postTool({
-    name: 'dokploy_auth_create_admin',
-    title: 'Create Admin Account',
-    description: 'Create the initial admin account for a fresh Dokploy installation. Requires an email address and a password (minimum 8 characters). This should only be called once during initial setup. Returns the created admin account details.',
-    schema: z.object({
-        email: z.string().email().describe('Email address for the admin account'),
-        password: z.string().min(8).describe('Password for the admin account (min 8 characters)'),
-    }).strict(),
-    endpoint: '/auth.createAdmin',
-});
-const createUser = postTool({
-    name: 'dokploy_auth_create_user',
-    title: 'Create User Account',
-    description: 'Create a new user account from an invitation token and password. The user must have received an invitation email containing a token and ID. Requires the invitation token, user/invitation ID, and a password (minimum 8 characters). Returns the created user account details.',
-    schema: z.object({
-        password: z.string().min(8).describe('Password for the new user (min 8 characters)'),
-        id: z.string().min(1).describe('The invitation or user ID'),
-        token: z.string().min(1).describe('The invitation token'),
-    }).strict(),
-    endpoint: '/auth.createUser',
-});
-const login = postTool({
-    name: 'dokploy_auth_login',
-    title: 'Login',
-    description: 'Log in to Dokploy with an email address and password. If the account has two-factor authentication enabled, a subsequent call to verify_login_2fa will be required. Returns a session token or a 2FA challenge depending on account configuration.',
-    schema: z.object({
-        email: z.string().email().describe('Email address of the account'),
-        password: z.string().min(8).describe('Account password (min 8 characters)'),
-    }).strict(),
-    endpoint: '/auth.login',
-});
-const get = getTool({
-    name: 'dokploy_auth_get',
-    title: 'Get Current User',
-    description: "Get the currently authenticated user's profile information. No parameters required. Returns the user's email, role, 2FA status, and other profile fields associated with the active session.",
-    schema: z.object({}).strict(),
-    endpoint: '/auth.get',
-});
-const logout = postTool({
-    name: 'dokploy_auth_logout',
-    title: 'Logout',
-    description: 'Log out the current user session and invalidate the active authentication token. No parameters required. Returns a confirmation that the session has been terminated.',
-    schema: z.object({}).strict(),
-    endpoint: '/auth.logout',
-});
-const update = postTool({
-    name: 'dokploy_auth_update',
-    title: 'Update Current User',
-    description: "Update the currently authenticated user's profile information. Accepts optional fields including email, password, role, profile image URL, and 2FA enabled status. Fields set to null will be cleared. Returns the updated user profile.",
-    schema: z.object({
-        email: z.string().email().nullable().describe('New email address, or null to clear'),
-        password: z.string().nullable().describe('New password, or null to keep current'),
-        id: z.string().min(1).optional().describe('The auth ID to update'),
-        rol: z.enum(['admin', 'user']).optional().describe('Role to assign: admin or user'),
-        image: z.string().optional().describe('Profile image URL'),
-        is2FAEnabled: z.boolean().optional().describe('Whether two-factor authentication is enabled'),
-    }).strict(),
-    endpoint: '/auth.update',
-});
-const generateToken = postTool({
-    name: 'dokploy_auth_generate_token',
-    title: 'Generate API Token',
-    description: 'Generate a new API token for the currently authenticated user. The token can be used for programmatic API access via the x-api-key header. No parameters required. Returns the generated token string.',
-    schema: z.object({}).strict(),
-    endpoint: '/auth.generateToken',
-});
-const one = getTool({
-    name: 'dokploy_auth_one',
-    title: 'Get User Auth Info',
-    description: "Get a specific user's authentication information by their auth ID. Requires the auth ID of the target user. Returns the user's email, role, 2FA status, and other auth-related fields.",
-    schema: z.object({
-        id: z.string().min(1).describe('The auth ID of the user to retrieve'),
-    }).strict(),
-    endpoint: '/auth.one',
-});
-const updateByAdmin = postTool({
-    name: 'dokploy_auth_update_by_admin',
-    title: 'Update User as Admin',
-    description: "Update any user's profile information with admin privileges. Requires the target user's auth ID and accepts fields including email, password, role, profile image URL, and 2FA enabled status. Fields set to null will be cleared. Returns the updated user profile.",
-    schema: z.object({
-        id: z.string().min(1).describe('The auth ID of the user to update'),
-        email: z.string().email().nullable().describe('New email address, or null to clear'),
-        password: z.string().nullable().describe('New password, or null to keep current'),
-        rol: z.enum(['admin', 'user']).optional().describe('Role to assign: admin or user'),
-        image: z.string().optional().describe('Profile image URL'),
-        is2FAEnabled: z.boolean().optional().describe('Whether two-factor authentication is enabled'),
-    }).strict(),
-    endpoint: '/auth.updateByAdmin',
-});
-const generate2FASecret = getTool({
-    name: 'dokploy_auth_generate_2fa_secret',
-    title: 'Generate 2FA Secret',
-    description: 'Generate a new two-factor authentication secret for the current user. This is the first step in setting up 2FA with an authenticator app. No parameters required. Returns the secret key and a QR code URL that can be scanned by an authenticator app.',
-    schema: z.object({}).strict(),
-    endpoint: '/auth.generate2FASecret',
-});
-const verify2FASetup = postTool({
-    name: 'dokploy_auth_verify_2fa_setup',
-    title: 'Verify 2FA Setup',
-    description: 'Verify and complete the two-factor authentication setup by providing a PIN from the authenticator app. Requires the 6-digit PIN and the 2FA secret that was generated during setup. Returns a confirmation that 2FA has been successfully enabled on the account.',
-    schema: z.object({
-        pin: z.string().min(6).describe('The 6-digit PIN from the authenticator app'),
-        secret: z.string().min(1).describe('The 2FA secret to verify against'),
-    }).strict(),
-    endpoint: '/auth.verify2FASetup',
-});
-const verifyLogin2FA = postTool({
-    name: 'dokploy_auth_verify_login_2fa',
-    title: 'Verify 2FA Login',
-    description: 'Verify a two-factor authentication PIN during the login process. This is called after a successful login attempt on an account with 2FA enabled. Requires the 6-digit PIN from the authenticator app and the auth ID of the user. Returns the authenticated session token.',
-    schema: z.object({
-        pin: z.string().min(6).describe('The 6-digit PIN from the authenticator app'),
-        id: z.string().min(1).describe('The auth ID of the user logging in'),
-    }).strict(),
-    endpoint: '/auth.verifyLogin2FA',
-});
-const disable2FA = postTool({
-    name: 'dokploy_auth_disable_2fa',
-    title: 'Disable 2FA',
-    description: "Disable two-factor authentication for the currently authenticated user's account. No parameters required. Returns a confirmation that 2FA has been removed from the account. Future logins will no longer require a 2FA PIN.",
-    schema: z.object({}).strict(),
-    endpoint: '/auth.disable2FA',
-});
-const verifyToken = postTool({
-    name: 'dokploy_auth_verify_token',
-    title: 'Verify Auth Token',
-    description: 'Verify the validity of the current authentication token. No parameters required. Returns whether the token is valid and has not expired. Useful for checking if a session is still active before making other API calls.',
-    schema: z.object({}).strict(),
-    endpoint: '/auth.verifyToken',
-});
-// ── export ───────────────────────────────────────────────────────────
-export const authTools = [
-    createAdmin,
-    createUser,
-    login,
-    get,
-    logout,
-    update,
-    generateToken,
-    one,
-    updateByAdmin,
-    generate2FASecret,
-    verify2FASetup,
-    verifyLogin2FA,
-    disable2FA,
-    verifyToken,
-];