@vibetools/dokploy-mcp 1.2.0 → 2.0.1

package/dist/codemode/tools/execute.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { createTool } from '../../mcp/tool-factory.js';
+import { createExecuteContext } from '../context/execute-context.js';
+import { createSandboxHost } from '../sandbox/host.js';
+import { resolveSandboxLimits } from '../sandbox/limits.js';
+import { runSandboxedFunction } from '../sandbox/runner.js';
+import { resolveSandboxRuntime } from '../sandbox/runtime.js';
+import { runExecuteInSubprocess } from '../sandbox/subprocess-runner.js';
+const executeSchema = z
+    .object({
+    code: z
+        .string()
+        .min(1)
+        .describe('An async arrow function receiving ({ dokploy, helpers }). ' +
+        'Example: async ({ dokploy }) => { const p = await dokploy.project.all(); return p }. ' +
+        'dokploy.<module>.<method>(params) calls the Dokploy API. ' +
+        'helpers: sleep(ms), assert(cond, msg), pick(obj, keys), limit(arr, n), selectOne(arr, pred).'),
+})
+    .strict();
+export function buildExecuteContext(executor, maxCalls = resolveSandboxLimits().maxCalls) {
+    return createExecuteContext(executor, maxCalls);
+}
+export async function runExecuteWithHost(code, host) {
+    const execution = resolveSandboxRuntime() === 'subprocess'
+        ? await runExecuteInSubprocess({
+            code,
+            onCall: async (procedure, input) => {
+                const result = await host.call(procedure, input);
+                return result.data;
+            },
+        })
+        : await runSandboxedFunction({
+            code,
+            context: (() => {
+                const context = buildExecuteContext((procedure, payload) => host.call(procedure, payload));
+                return {
+                    dokploy: context.dokploy,
+                    helpers: context.helpers,
+                };
+            })(),
+        });
+    return {
+        result: execution.result,
+        logs: execution.logs,
+        calls: host.getCalls(),
+    };
+}
+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.',
+    schema: executeSchema,
+    annotations: { openWorldHint: true },
+    handler: async ({ input }) => {
+        const host = createSandboxHost();
+        return runExecuteWithHost(input.code, host);
+    },
+});

package/dist/codemode/tools/index.d.ts

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

package/dist/codemode/tools/index.js

@@ -0,0 +1,3 @@
+import { executeTool } from './execute.js';
+import { searchTool } from './search.js';
+export const codeModeTools = [searchTool, executeTool];

package/dist/codemode/tools/search.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '../../mcp/tool-factory.js';
+export declare const searchTool: ToolDefinition;

package/dist/codemode/tools/search.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { createTool } from '../../mcp/tool-factory.js';
+import { createSearchCatalogView } from '../context/search-context.js';
+import { runSandboxedFunction } from '../sandbox/runner.js';
+import { resolveSandboxRuntime } from '../sandbox/runtime.js';
+import { runSearchInSubprocess } from '../sandbox/subprocess-runner.js';
+const searchSchema = z
+    .object({
+    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).'),
+})
+    .strict();
+const searchCatalog = createSearchCatalogView();
+const MAX_SEARCH_OUTPUT_BYTES = 32 * 1024;
+function boundSearchResult(value) {
+    if (Array.isArray(value)) {
+        return trimArrayToBytes(value);
+    }
+    if (value && typeof value === 'object' && 'matches' in value) {
+        const typed = value;
+        if (Array.isArray(typed.matches)) {
+            return {
+                ...typed,
+                matches: trimArrayToBytes(typed.matches),
+            };
+        }
+    }
+    return value;
+}
+function trimArrayToBytes(items) {
+    const limited = items.slice(0, 50);
+    let length = limited.length;
+    while (length > 0) {
+        const candidate = limited.slice(0, length);
+        const bytes = Buffer.byteLength(JSON.stringify(candidate), 'utf8');
+        if (bytes <= MAX_SEARCH_OUTPUT_BYTES) {
+            return candidate;
+        }
+        length -= 1;
+    }
+    return [];
+}
+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. ' +
+        'Returns procedure names, required/optional parameters, and HTTP methods.',
+    schema: searchSchema,
+    annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    handler: async ({ input }) => {
+        const execution = resolveSandboxRuntime() === 'subprocess'
+            ? await runSearchInSubprocess({ code: input.code })
+            : await runSandboxedFunction({
+                code: input.code,
+                context: {
+                    catalog: searchCatalog,
+                },
+            });
+        return {
+            result: boundSearchResult(execution.result),
+            logs: execution.logs,
+        };
+    },
+});

package/dist/generated/dokploy-catalog.d.ts

@@ -0,0 +1,27 @@
+export interface CatalogEndpoint {
+    procedure: string;
+    method: string;
+    path: string;
+    tag: string;
+    summary: string | null;
+    description: string | null;
+    inputKind: 'query' | 'body';
+    requiredInputs: string[];
+    optionalInputs: string[];
+    response: {
+        type: string;
+        keys: string[];
+    };
+}
+export interface DokployCatalog {
+    version: string;
+    endpointCount: number;
+    tagCount: number;
+    endpoints: CatalogEndpoint[];
+    byTag: Record<string, number[]>;
+    byProcedure: Record<string, number>;
+    byPath: Record<string, number>;
+}
+export declare const dokployCatalog: DokployCatalog;
+export declare function getCatalogEndpoint(id: string): CatalogEndpoint | undefined;
+export declare function getCatalogEndpointsByTag(tag: string): (CatalogEndpoint | undefined)[];

package/dist/generated/dokploy-catalog.js

@@ -0,0 +1,16 @@
+// Generated by scripts/v2/build-openapi-index.mjs
+import openapiIndex from './openapi-index.json' with { type: 'json' };
+export const dokployCatalog = openapiIndex;
+export function getCatalogEndpoint(id) {
+    const byProcedureIndex = dokployCatalog.byProcedure[id];
+    if (byProcedureIndex !== undefined)
+        return dokployCatalog.endpoints[byProcedureIndex];
+    const byPathIndex = dokployCatalog.byPath[id];
+    if (byPathIndex !== undefined)
+        return dokployCatalog.endpoints[byPathIndex];
+    return undefined;
+}
+export function getCatalogEndpointsByTag(tag) {
+    const indexes = dokployCatalog.byTag[tag] ?? [];
+    return indexes.map((index) => dokployCatalog.endpoints[index]).filter(Boolean);
+}