@dokploy/mcp 0.29.13 → 0.30.0

package/build/server.js

@@ -6,21 +6,61 @@ import { createHandler } from "./handler.js";
 import { createLogger } from "./utils/logger.js";
 const logger = createLogger("MCP-Server");
 const JSON_SCHEMA_2020_12 = "https://json-schema.org/draft/2020-12/schema";
+const LARGE_TOOLSET_WARNING_THRESHOLD = 150;
+const TOOL_PRESETS = {
+    all: null,
+    minimal: "project,application",
+    core: "project,server,application",
+    deploy: "project,environment,server,application,compose,domain,deployment",
+    databases: "postgres,redis,mysql,mariadb,mongo,libsql",
+    git: "github,gitlab,bitbucket,gitea,gitProvider,registry,sshKey",
+};
+function parseTagList(value) {
+    return new Set((value ?? "")
+        .split(",")
+        .map((tag) => tag.trim().toLowerCase())
+        .filter(Boolean));
+}
+function isToolPreset(value) {
+    return Object.hasOwn(TOOL_PRESETS, value);
+}
 function getEnabledTools() {
     const enabledTags = process.env.DOKPLOY_ENABLED_TAGS;
-    if (!enabledTags) {
-        return generatedTools;
+    const disabledTags = parseTagList(process.env.DOKPLOY_DISABLED_TAGS);
+    const requestedPreset = process.env.DOKPLOY_TOOL_PRESET?.trim().toLowerCase() || "all";
+    const preset = isToolPreset(requestedPreset) ? requestedPreset : "all";
+    if (!isToolPreset(requestedPreset)) {
+        logger.warn("Unknown tool preset, falling back to all tools", {
+            requestedPreset,
+            availablePresets: Object.keys(TOOL_PRESETS),
+        });
     }
-    const tags = new Set(enabledTags
-        .split(",")
-        .map((t) => t.trim().toLowerCase())
-        .filter(Boolean));
-    const filtered = generatedTools.filter((tool) => tags.has(tool.tag.toLowerCase()));
-    logger.info("Filtered tools by tags", {
-        enabledTags: [...tags],
+    let selectedTags = parseTagList(enabledTags);
+    const source = selectedTags.size > 0 ? "enabled-tags" : "preset";
+    if (selectedTags.size === 0) {
+        selectedTags = parseTagList(TOOL_PRESETS[preset] ?? undefined);
+    }
+    let filtered = selectedTags.size > 0
+        ? generatedTools.filter((tool) => selectedTags.has(tool.tag.toLowerCase()))
+        : generatedTools;
+    if (disabledTags.size > 0) {
+        filtered = filtered.filter((tool) => !disabledTags.has(tool.tag.toLowerCase()));
+    }
+    const context = {
         total: generatedTools.length,
         loaded: filtered.length,
-    });
+        source,
+        preset,
+        enabledTags: [...selectedTags],
+        disabledTags: [...disabledTags],
+    };
+    logger.info("Loaded tools", context);
+    if (filtered.length > LARGE_TOOLSET_WARNING_THRESHOLD) {
+        logger.warn("Large toolset loaded; some MCP clients or LLM providers may time out", {
+            ...context,
+            recommendation: "Set DOKPLOY_TOOL_PRESET=minimal or DOKPLOY_ENABLED_TAGS to reduce tool count",
+        });
+    }
     return filtered;
 }
 function stripNestedSchemaKeys(value) {
@@ -41,6 +81,40 @@ function stripNestedSchemaKeys(value) {
         }
     }
 }
+// Provider schema validators (OpenAI, Sonnet strict, DeepSeek) accept only a
+// conservative subset of ECMA-262: lookarounds and loosely-escaped character
+// classes (e.g. an unescaped "[" inside a class) are rejected even though JS
+// allows them. Lookarounds compile fine under the strict "v" flag, so they
+// need their own check; everything else is caught by the "v" compile test.
+function usesUnsupportedRegexSyntax(pattern) {
+    if (typeof pattern !== "string")
+        return false;
+    if (/\(\?<?[=!]/.test(pattern))
+        return true;
+    try {
+        new RegExp(pattern, "v");
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function stripUnsupportedRegexPatterns(value) {
+    if (value === null || typeof value !== "object")
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            stripUnsupportedRegexPatterns(item);
+        return;
+    }
+    const record = value;
+    if (usesUnsupportedRegexSyntax(record.pattern)) {
+        delete record.pattern;
+    }
+    for (const child of Object.values(record)) {
+        stripUnsupportedRegexPatterns(child);
+    }
+}
 // Claude's API requires JSON Schema draft 2020-12. The MCP SDK's built-in
 // Zod→JSON Schema converter emits draft-07 by default, which causes a 400
 // error on tools/list. We bypass the SDK's auto-generated handler by
@@ -52,6 +126,7 @@ function toDraft2020_12JsonSchema(schema) {
         strictUnions: true,
     });
     stripNestedSchemaKeys(result);
+    stripUnsupportedRegexPatterns(result);
     result.$schema = JSON_SCHEMA_2020_12;
     return result;
 }

package/build/utils/clientConfig.js

@@ -54,7 +54,7 @@ class ConfigManager {
         if (!authToken) {
             throw new Error("Environment variable DOKPLOY_API_KEY is not defined");
         }
-        const redactEnv = parseBoolean(process.env.DOKPLOY_REDACT_ENV, false);
+        const redactEnv = parseBoolean(process.env.DOKPLOY_REDACT_ENV, true);
         const parsedFields = process.env.DOKPLOY_REDACT_FIELDS?.split(",")
             .map((f) => f.trim())
             .filter((f) => f.length > 0) ?? [];

package/build/utils/redactSensitive.js

@@ -43,8 +43,8 @@ const REDACTED_PLACEHOLDER = "[REDACTED]";
 export function redactSensitive(data, fields) {
     if (fields.length === 0)
         return data;
-    const lowered = new Set(fields.map((f) => f.toLowerCase()));
-    return walk(data, lowered, new WeakSet());
+    const suffixes = fields.map((f) => f.toLowerCase());
+    return walk(data, suffixes, new WeakSet());
 }
 function isPlainObject(value) {
     if (value === null || typeof value !== "object")
@@ -52,12 +52,12 @@ function isPlainObject(value) {
     const proto = Object.getPrototypeOf(value);
     return proto === Object.prototype || proto === null;
 }
-function walk(value, fields, seen) {
+function walk(value, suffixes, seen) {
     if (Array.isArray(value)) {
         if (seen.has(value))
             return value;
         seen.add(value);
-        return value.map((item) => walk(item, fields, seen));
+        return value.map((item) => walk(item, suffixes, seen));
     }
     if (isPlainObject(value)) {
         if (seen.has(value))
@@ -67,11 +67,12 @@ function walk(value, fields, seen) {
         for (const [key, val] of Object.entries(value)) {
             if (key === "__proto__" || key === "constructor" || key === "prototype")
                 continue;
-            if (fields.has(key.toLowerCase())) {
+            const loweredKey = key.toLowerCase();
+            if (suffixes.some((suffix) => loweredKey.endsWith(suffix))) {
                 out[key] = val === null || val === undefined ? val : REDACTED_PLACEHOLDER;
             }
             else {
-                out[key] = walk(val, fields, seen);
+                out[key] = walk(val, suffixes, seen);
             }
         }
         return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dokploy/mcp",
-  "version": "0.29.13",
+  "version": "0.30.0",
   "description": "MCP Server for Dokploy API",
   "main": "build/index.js",
   "bin": {