@vibetools/dokploy-mcp 2.0.1 → 2.1.1

package/dist/codemode/sandbox/runner.js

@@ -16,32 +16,57 @@ function deepFreeze(value) {
     }
     return value;
 }
+const ARROW_FN_RE = /^\s*async\s*\(/;
+/**
+ * Auto-wraps raw code into an async function if the agent didn't provide one.
+ * Accepts all these forms:
+ *   1. async ({ dokploy }) => { ... }           -- arrow with destructuring (original)
+ *   2. async (ctx) => { ... }                   -- arrow with param
+ *   3. async () => dokploy.project.all()        -- arrow using globals
+ *   4. dokploy.project.all()                    -- raw expression (auto-wrapped)
+ *   5. const x = await dokploy.project.all()    -- raw statements (auto-wrapped)
+ */
+function wrapSandboxCode(code) {
+    const trimmed = code.trim();
+    if (ARROW_FN_RE.test(trimmed)) {
+        return trimmed;
+    }
+    // Raw code -- wrap in an async function that receives context but ignores it
+    // (context keys are already available as globals)
+    const hasReturn = /\breturn\b/.test(trimmed);
+    const body = hasReturn ? trimmed : `return (${trimmed})`;
+    return `async () => { ${body} }`;
+}
 export async function runSandboxedFunction({ code, context, limits: providedLimits, }) {
     const limits = providedLimits ?? resolveSandboxLimits();
     const logs = [];
     let loggedBytes = 0;
     const frozenContext = deepFreeze(context);
-    const sandbox = createContext({
-        __context: frozenContext,
-        console: {
-            log: (...args) => {
-                const line = args
-                    .map((arg) => {
-                    try {
-                        return typeof arg === 'string' ? arg : JSON.stringify(arg);
-                    }
-                    catch {
-                        return String(arg);
-                    }
-                })
-                    .join(' ');
-                loggedBytes += Buffer.byteLength(line, 'utf8');
-                if (loggedBytes > limits.maxLogBytes) {
-                    throw new Error(`Sandbox logs exceeded ${limits.maxLogBytes} bytes.`);
+    const consoleProxy = {
+        log: (...args) => {
+            const line = args
+                .map((arg) => {
+                try {
+                    return typeof arg === 'string' ? arg : JSON.stringify(arg);
+                }
+                catch {
+                    return String(arg);
                 }
-                logs.push(line);
-            },
+            })
+                .join(' ');
+            loggedBytes += Buffer.byteLength(line, 'utf8');
+            if (loggedBytes > limits.maxLogBytes) {
+                throw new Error(`Sandbox logs exceeded ${limits.maxLogBytes} bytes.`);
+            }
+            logs.push(line);
         },
+    };
+    const sandbox = createContext({
+        __context: frozenContext,
+        // Expose context keys as top-level globals so agents can write
+        // `dokploy.project.all()` or `catalog.searchText("x")` directly
+        ...frozenContext,
+        console: consoleProxy,
         process: undefined,
         fetch: undefined,
         require: undefined,
@@ -63,15 +88,13 @@ export async function runSandboxedFunction({ code, context, limits: providedLimi
             wasm: false,
         },
     });
+    const wrappedCode = wrapSandboxCode(code);
     const script = new Script(`
       (async () => {
-        const __fn = (${code})
+        const __fn = (${wrappedCode})
         if (typeof __fn !== 'function') {
           throw new Error('Sandbox code must evaluate to a function.')
         }
-        if (__fn.constructor?.name !== 'AsyncFunction') {
-          throw new Error('Sandbox code must evaluate to an async function.')
-        }
         return await __fn(__context)
       })()
     `, {

package/dist/codemode/tools/execute.js

@@ -11,10 +11,11 @@ const executeSchema = z
     code: z
         .string()
         .min(1)
-        .describe('An async arrow function receiving ({ dokploy, helpers }). ' +
-        'Example: async ({ dokploy }) => { const p = await dokploy.project.all(); return p }. ' +
+        .describe('JavaScript code. `dokploy` and `helpers` are globals -- do NOT wrap in a function. ' +
+        'Simple: `await dokploy.project.all()`. ' +
+        'Multi-step: `const app = await dokploy.application.one({ applicationId: "abc" }); return app.name`. ' +
         'dokploy.<module>.<method>(params) calls the Dokploy API. ' +
-        'helpers: sleep(ms), assert(cond, msg), pick(obj, keys), limit(arr, n), selectOne(arr, pred).'),
+        'helpers: sleep(ms), assert(cond, msg), pick(obj, keys), limit(arr, n).'),
 })
     .strict();
 export function buildExecuteContext(executor, maxCalls = resolveSandboxLimits().maxCalls) {
@@ -48,13 +49,13 @@ export async function runExecuteWithHost(code, host) {
 export const executeTool = createTool({
     name: 'execute',
     title: 'Execute Dokploy Workflow',
-    description: 'Execute a sandboxed Dokploy workflow. ' +
-        'The code parameter must be an async arrow function: async ({ dokploy, helpers }) => { ... }. ' +
-        'Use dokploy.<module>.<method>(params) to call any Dokploy API procedure ' +
-        '(e.g. dokploy.application.one({ applicationId }), dokploy.project.all()). ' +
-        'Available modules: project, environment, application, compose, domain, postgres, mysql, mariadb, mongo, redis, ' +
-        'deployment, docker, server, settings, user, notification, backup, mounts, registry, certificates, and more. ' +
-        'Use search tool first to discover exact procedure names and required parameters.',
+    description: 'Run JavaScript code against the Dokploy API. ' +
+        'IMPORTANT: Do NOT wrap code in a function -- `dokploy` and `helpers` are already globals. ' +
+        'Write bare code: `await dokploy.project.all()` or `const x = await dokploy.application.one({ applicationId: "id" }); return x`. ' +
+        'dokploy.<module>.<method>(params) calls the API. ' +
+        'Modules: project, environment, application, compose, domain, postgres, mysql, mariadb, mongo, redis, ' +
+        'deployment, docker, server, settings, user, notification, backup, mounts, registry, certificates, schedule, patch, sshKey, gitProvider, and more. ' +
+        'Use search tool first to discover procedure names and required parameters.',
     schema: executeSchema,
     annotations: { openWorldHint: true },
     handler: async ({ input }) => {

package/dist/codemode/tools/search.js

@@ -9,10 +9,10 @@ const searchSchema = z
     code: z
         .string()
         .min(1)
-        .describe('An async arrow function receiving ({ catalog }). ' +
-        'Example: async ({ catalog }) => catalog.searchText("application deploy"). ' +
-        'catalog methods: searchText(query), get(procedure), getByTag(tag), ' +
-        'endpoints (array of all procedures), byTag (grouped by module).'),
+        .describe('JavaScript code. `catalog` is a global -- do NOT wrap in a function. ' +
+        'Examples: `catalog.searchText("application deploy")` | ' +
+        '`catalog.getByTag("compose")` | `catalog.get("application.one")`. ' +
+        'Methods: searchText(query), get(procedure), getByTag(tag), endpoints, byTag.'),
 })
     .strict();
 const searchCatalog = createSearchCatalogView();
@@ -48,11 +48,9 @@ function trimArrayToBytes(items) {
 export const searchTool = createTool({
     name: 'search',
     title: 'Search Dokploy API',
-    description: 'Search the Dokploy API catalog to discover procedures, parameters, and modules. ' +
-        'The code parameter must be an async arrow function: async ({ catalog }) => { ... }. ' +
-        'Use catalog.searchText("query") to find procedures by keyword, ' +
-        'catalog.getByTag("application") to list all procedures in a module, ' +
-        'catalog.get("application.one") to get details of a specific procedure. ' +
+    description: 'Search the Dokploy API catalog. ' +
+        'IMPORTANT: Do NOT wrap code in a function -- `catalog` is already a global. ' +
+        'Write bare code: `catalog.searchText("deploy")` or `catalog.getByTag("application")` or `catalog.get("application.one")`. ' +
         'Returns procedure names, required/optional parameters, and HTTP methods.',
     schema: searchSchema,
     annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibetools/dokploy-mcp",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Dokploy MCP server with Code Mode by default",
   "type": "module",
   "exports": {