@vibetools/dokploy-mcp 1.0.0 → 2.0.0

package/dist/codemode/tools/execute.js

@@ -0,0 +1,52 @@
+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('Async JavaScript function to execute a Dokploy workflow'),
+})
+    .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 against the generated Dokploy SDK.',
+    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,62 @@
+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('Async JavaScript function to search the Dokploy API catalog'),
+})
+    .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 by executing sandboxed code against a compact API index.',
+    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);
+}