@vibetools/dokploy-mcp 2.1.0 → 2.2.0

package/dist/codemode/overrides/procedure-overrides.js

@@ -0,0 +1,166 @@
+import { procedureSchemas } from '../../generated/dokploy-schemas.js';
+const applicationOneMcpOnlyKeys = new Set(['select', 'includeDeployments', 'deploymentLimit']);
+const applicationOneInputSchema = {
+    type: 'object',
+    properties: {
+        applicationId: {
+            type: 'string',
+            minLength: 1,
+        },
+        select: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+        },
+        includeDeployments: {
+            type: 'boolean',
+        },
+        deploymentLimit: {
+            type: 'integer',
+        },
+    },
+    required: ['applicationId'],
+    additionalProperties: false,
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeSelectedFields(select) {
+    if (!Array.isArray(select)) {
+        return null;
+    }
+    const normalized = [];
+    const seen = new Set();
+    for (const entry of select) {
+        if (typeof entry !== 'string') {
+            continue;
+        }
+        const field = entry.trim();
+        if (field.length === 0 || seen.has(field)) {
+            continue;
+        }
+        seen.add(field);
+        normalized.push(field);
+    }
+    return normalized;
+}
+function pickSelectedFields(value, select) {
+    const normalized = normalizeSelectedFields(select);
+    if (!normalized) {
+        return { ...value };
+    }
+    return Object.fromEntries(normalized.filter((field) => Object.hasOwn(value, field)).map((field) => [field, value[field]]));
+}
+function applyDeploymentControls(value, input) {
+    if (input.includeDeployments === false) {
+        const { deployments: _deployments, ...rest } = value;
+        return rest;
+    }
+    if (typeof input.deploymentLimit === 'number' && Array.isArray(value.deployments)) {
+        return {
+            ...value,
+            deployments: value.deployments.slice(0, input.deploymentLimit),
+        };
+    }
+    return value;
+}
+function validateApplicationOneInput(input) {
+    const errors = [];
+    if ('select' in input) {
+        if (!Array.isArray(input.select) || input.select.length === 0) {
+            errors.push('select must be a non-empty array of field names');
+        }
+        else {
+            for (const [index, field] of input.select.entries()) {
+                if (typeof field !== 'string' || field.trim().length === 0) {
+                    errors.push(`select[${index}] must be a non-empty string`);
+                }
+            }
+        }
+    }
+    if ('deploymentLimit' in input) {
+        if (typeof input.deploymentLimit !== 'number' ||
+            !Number.isInteger(input.deploymentLimit) ||
+            input.deploymentLimit < 0) {
+            errors.push('deploymentLimit must be a non-negative integer');
+        }
+    }
+    if (input.includeDeployments === false && input.deploymentLimit !== undefined) {
+        errors.push('deploymentLimit cannot be used when includeDeployments is false');
+    }
+    return errors;
+}
+function mapApplicationOneInput(input) {
+    return Object.fromEntries(Object.entries(input).filter(([key]) => !applicationOneMcpOnlyKeys.has(key)));
+}
+function transformApplicationOneResponse(data, input) {
+    if (!isRecord(data)) {
+        return data;
+    }
+    const selected = pickSelectedFields(data, input.select);
+    return applyDeploymentControls(selected, input);
+}
+const procedureOverrides = {
+    'application.one': {
+        inputSchema: applicationOneInputSchema,
+        mapInput: mapApplicationOneInput,
+        validateInput: validateApplicationOneInput,
+        transformResponse: transformApplicationOneResponse,
+    },
+};
+function getGeneratedProcedureSchema(procedure) {
+    return procedureSchemas[procedure];
+}
+function extractObjectInputMetadata(schema) {
+    if (!isRecord(schema) || schema.type !== 'object' || !isRecord(schema.properties)) {
+        return {
+            requiredInputs: [],
+            optionalInputs: [],
+        };
+    }
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((key) => typeof key === 'string')
+        : [];
+    const requiredSet = new Set(required);
+    const optional = Object.keys(schema.properties).filter((key) => !requiredSet.has(key));
+    return {
+        requiredInputs: required,
+        optionalInputs: optional,
+    };
+}
+export function getEffectiveProcedureSchema(procedure) {
+    const generated = getGeneratedProcedureSchema(procedure);
+    if (!generated) {
+        return null;
+    }
+    const override = procedureOverrides[procedure];
+    if (!override) {
+        return generated;
+    }
+    return {
+        ...generated,
+        inputSchema: override.inputSchema ?? generated.inputSchema,
+    };
+}
+export function applyProcedureInputMetadata(endpoint) {
+    const effectiveSchema = getEffectiveProcedureSchema(endpoint.procedure);
+    if (!effectiveSchema) {
+        return endpoint;
+    }
+    const metadata = extractObjectInputMetadata(effectiveSchema.inputSchema);
+    return {
+        ...endpoint,
+        requiredInputs: metadata.requiredInputs,
+        optionalInputs: metadata.optionalInputs,
+    };
+}
+export function mapProcedureInput(procedure, input) {
+    return procedureOverrides[procedure]?.mapInput?.(input) ?? input;
+}
+export function validateProcedureInput(procedure, input) {
+    return procedureOverrides[procedure]?.validateInput?.(input) ?? [];
+}
+export function transformProcedureResponse(procedure, input, data) {
+    return procedureOverrides[procedure]?.transformResponse?.(data, input) ?? data;
+}

package/dist/codemode/overrides/virtual-procedures.d.ts

@@ -0,0 +1,29 @@
+import type { CatalogEndpoint } from '../../generated/dokploy-catalog.js';
+export interface VirtualCatalogEndpoint extends CatalogEndpoint {
+    virtual: true;
+}
+export interface VirtualProcedureSchema {
+    method: 'GET' | 'POST';
+    path: string;
+    tag: string;
+    inputKind: 'query' | 'body';
+    inputSchema: unknown;
+    outputSchema: unknown;
+    virtual: true;
+}
+interface VirtualProcedureContext {
+    call: (procedure: string, input?: Record<string, unknown>) => Promise<unknown>;
+}
+interface VirtualProcedureDefinition {
+    endpoint: VirtualCatalogEndpoint;
+    schema: VirtualProcedureSchema;
+    validateInput?: (input: Record<string, unknown>) => string[];
+    execute: (input: Record<string, unknown>, context: VirtualProcedureContext) => Promise<unknown>;
+}
+export declare function getVirtualProcedureDefinition(procedure: string): VirtualProcedureDefinition | null;
+export declare function getVirtualProcedureSchema(procedure: string): VirtualProcedureSchema | null;
+export declare function getVirtualCatalogEndpoints(): VirtualCatalogEndpoint[];
+export declare function isVirtualProcedure(procedure: string): boolean;
+export declare function validateVirtualProcedureInput(procedure: string, input: Record<string, unknown>): string[];
+export declare function executeVirtualProcedure(procedure: string, input: Record<string, unknown>, context: VirtualProcedureContext): Promise<unknown>;
+export {};

package/dist/codemode/overrides/virtual-procedures.js

@@ -0,0 +1,330 @@
+function createApplicationManyInputSchema() {
+    return {
+        type: 'object',
+        properties: {
+            applicationIds: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                },
+            },
+            select: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                },
+            },
+            includeDeployments: {
+                type: 'boolean',
+            },
+            deploymentLimit: {
+                type: 'integer',
+            },
+        },
+        required: ['applicationIds'],
+        additionalProperties: false,
+    };
+}
+function createApplicationManyOutputSchema() {
+    return {
+        type: 'object',
+        properties: {
+            items: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: true,
+                },
+            },
+            total: {
+                type: 'integer',
+            },
+        },
+        required: ['items', 'total'],
+        additionalProperties: false,
+    };
+}
+function validateStringList(value, key, options = {}) {
+    const errors = [];
+    if (!Array.isArray(value)) {
+        return [`${key} must be an array of strings`];
+    }
+    if (options.requireNonEmptyArray && value.length === 0) {
+        errors.push(`${key} must be a non-empty array of field names`);
+    }
+    for (const [index, entry] of value.entries()) {
+        if (typeof entry !== 'string' || entry.trim().length === 0) {
+            errors.push(`${key}[${index}] must be a non-empty string`);
+        }
+    }
+    return errors;
+}
+function validateDeploymentControls(input) {
+    const errors = [];
+    if ('deploymentLimit' in input) {
+        if (typeof input.deploymentLimit !== 'number' ||
+            !Number.isInteger(input.deploymentLimit) ||
+            input.deploymentLimit < 0) {
+            errors.push('deploymentLimit must be a non-negative integer');
+        }
+    }
+    if (input.includeDeployments === false && input.deploymentLimit !== undefined) {
+        errors.push('deploymentLimit cannot be used when includeDeployments is false');
+    }
+    return errors;
+}
+function validateApplicationManyInput(input) {
+    const errors = [];
+    errors.push(...validateStringList(input.applicationIds, 'applicationIds'));
+    if ('select' in input) {
+        errors.push(...validateStringList(input.select, 'select', { requireNonEmptyArray: true }));
+    }
+    errors.push(...validateDeploymentControls(input));
+    return errors;
+}
+function buildApplicationOneInput(applicationId, input) {
+    const nextInput = { applicationId };
+    if ('select' in input) {
+        nextInput.select = input.select;
+    }
+    if ('includeDeployments' in input) {
+        nextInput.includeDeployments = input.includeDeployments;
+    }
+    if ('deploymentLimit' in input) {
+        nextInput.deploymentLimit = input.deploymentLimit;
+    }
+    return nextInput;
+}
+async function executeApplicationMany(input, context) {
+    const applicationIds = input.applicationIds?.map((applicationId) => applicationId.trim()) ??
+        [];
+    const items = [];
+    for (const applicationId of applicationIds) {
+        const item = await context.call('application.one', buildApplicationOneInput(applicationId, input));
+        items.push(item);
+    }
+    return {
+        items,
+        total: items.length,
+    };
+}
+function createProjectOverviewInputSchema() {
+    return {
+        type: 'object',
+        properties: {
+            projectId: {
+                type: 'string',
+                minLength: 1,
+            },
+            pageSize: {
+                type: 'integer',
+            },
+        },
+        required: ['projectId'],
+        additionalProperties: false,
+    };
+}
+function createProjectOverviewOutputSchema() {
+    return {
+        type: 'object',
+        properties: {
+            projectId: {
+                type: 'string',
+            },
+            name: {
+                anyOf: [{ type: 'string' }, { type: 'null' }],
+            },
+            environments: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: true,
+                },
+            },
+        },
+        required: ['projectId', 'name', 'environments'],
+        additionalProperties: false,
+    };
+}
+function validateProjectOverviewInput(input) {
+    const errors = [];
+    if (typeof input.projectId !== 'string' || input.projectId.trim().length === 0) {
+        errors.push('projectId must be a non-empty string');
+    }
+    if ('pageSize' in input) {
+        if (typeof input.pageSize !== 'number' ||
+            !Number.isInteger(input.pageSize) ||
+            input.pageSize <= 0) {
+            errors.push('pageSize must be a positive integer');
+        }
+    }
+    return errors;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getStringOrNull(value) {
+    return typeof value === 'string' ? value : null;
+}
+function getArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function buildProjectOverviewApplication(value) {
+    if (!isRecord(value)) {
+        return {
+            applicationId: null,
+            name: null,
+            appName: null,
+            applicationStatus: null,
+            domains: [],
+            mounts: [],
+            watchPaths: [],
+            lastDeployment: null,
+        };
+    }
+    const deployments = getArray(value.deployments);
+    return {
+        applicationId: getStringOrNull(value.applicationId),
+        name: getStringOrNull(value.name),
+        appName: getStringOrNull(value.appName),
+        applicationStatus: getStringOrNull(value.applicationStatus),
+        domains: getArray(value.domains),
+        mounts: getArray(value.mounts),
+        watchPaths: getArray(value.watchPaths),
+        lastDeployment: deployments[0] ?? null,
+    };
+}
+async function executeProjectOverview(input, context) {
+    const projectId = String(input.projectId);
+    const project = await context.call('project.one', { projectId });
+    const environments = await context.call('environment.byProjectId', { projectId });
+    const environmentItems = getArray(environments);
+    const overviewEnvironments = [];
+    for (const environment of environmentItems) {
+        if (!isRecord(environment)) {
+            continue;
+        }
+        const environmentId = getStringOrNull(environment.environmentId);
+        if (!environmentId) {
+            continue;
+        }
+        // Use environment.one to get application references (application.search
+        // does not reliably filter by environmentId in all Dokploy versions)
+        const envDetail = await context.call('environment.one', { environmentId });
+        const appRefs = isRecord(envDetail) ? getArray(envDetail.applications) : [];
+        const overviewApplications = [];
+        for (const appRef of appRefs) {
+            const applicationId = isRecord(appRef) ? getStringOrNull(appRef.applicationId) : null;
+            if (!applicationId) {
+                continue;
+            }
+            const detail = await context.call('application.one', {
+                applicationId,
+                select: [
+                    'applicationId',
+                    'name',
+                    'appName',
+                    'applicationStatus',
+                    'domains',
+                    'mounts',
+                    'watchPaths',
+                    'deployments',
+                ],
+                deploymentLimit: 1,
+            });
+            overviewApplications.push(buildProjectOverviewApplication(detail));
+        }
+        overviewEnvironments.push({
+            environmentId,
+            name: getStringOrNull(environment.name),
+            applications: overviewApplications,
+        });
+    }
+    return {
+        projectId,
+        name: isRecord(project) ? getStringOrNull(project.name) : null,
+        environments: overviewEnvironments,
+    };
+}
+const virtualProcedureDefinitions = {
+    'application.many': {
+        endpoint: {
+            procedure: 'application.many',
+            method: 'GET',
+            path: '/virtual/application.many',
+            tag: 'application',
+            summary: 'Read multiple applications in one execute workflow',
+            description: 'MCP-only virtual helper that fans out to application.one while preserving input order and execute call budgeting.',
+            inputKind: 'body',
+            requiredInputs: ['applicationIds'],
+            optionalInputs: ['select', 'includeDeployments', 'deploymentLimit'],
+            response: {
+                type: 'object',
+                keys: ['items', 'total'],
+            },
+            virtual: true,
+        },
+        schema: {
+            method: 'GET',
+            path: '/virtual/application.many',
+            tag: 'application',
+            inputKind: 'body',
+            inputSchema: createApplicationManyInputSchema(),
+            outputSchema: createApplicationManyOutputSchema(),
+            virtual: true,
+        },
+        validateInput: validateApplicationManyInput,
+        execute: executeApplicationMany,
+    },
+    'project.overview': {
+        endpoint: {
+            procedure: 'project.overview',
+            method: 'GET',
+            path: '/virtual/project.overview',
+            tag: 'project',
+            summary: 'Read an opinionated overview of one project',
+            description: 'MCP-only virtual helper that aggregates project, environment, application, mounts, watch paths, domains, and the latest deployment.',
+            inputKind: 'body',
+            requiredInputs: ['projectId'],
+            optionalInputs: ['pageSize'],
+            response: {
+                type: 'object',
+                keys: ['projectId', 'name', 'environments'],
+            },
+            virtual: true,
+        },
+        schema: {
+            method: 'GET',
+            path: '/virtual/project.overview',
+            tag: 'project',
+            inputKind: 'body',
+            inputSchema: createProjectOverviewInputSchema(),
+            outputSchema: createProjectOverviewOutputSchema(),
+            virtual: true,
+        },
+        validateInput: validateProjectOverviewInput,
+        execute: executeProjectOverview,
+    },
+};
+export function getVirtualProcedureDefinition(procedure) {
+    return virtualProcedureDefinitions[procedure] ?? null;
+}
+export function getVirtualProcedureSchema(procedure) {
+    return getVirtualProcedureDefinition(procedure)?.schema ?? null;
+}
+export function getVirtualCatalogEndpoints() {
+    return Object.values(virtualProcedureDefinitions).map((definition) => definition.endpoint);
+}
+export function isVirtualProcedure(procedure) {
+    return procedure in virtualProcedureDefinitions;
+}
+export function validateVirtualProcedureInput(procedure, input) {
+    return getVirtualProcedureDefinition(procedure)?.validateInput?.(input) ?? [];
+}
+export async function executeVirtualProcedure(procedure, input, context) {
+    const definition = getVirtualProcedureDefinition(procedure);
+    if (!definition) {
+        throw new Error(`Unknown virtual procedure: ${procedure}`);
+    }
+    return definition.execute(input, context);
+}

package/dist/codemode/sandbox/worker-entry.js

@@ -1,6 +1,6 @@
-import { createGeneratedDokployRuntime } from '../../generated/dokploy-sdk.js';
-import { buildHelpers } from '../context/execute-context.js';
+import { createExecuteContext } from '../context/execute-context.js';
 import { createSearchCatalogView } from '../context/search-context.js';
+import { resolveSandboxLimits } from './limits.js';
 import { runSandboxedFunction } from './runner.js';
 const pendingCalls = new Map();
 let requestIdCounter = 0;
@@ -44,10 +44,27 @@ process.on('message', async (message) => {
         const limits = payload.limits ?? undefined;
         const context = payload.mode === 'search'
             ? { catalog: createSearchCatalogView() }
-            : {
-                dokploy: createGeneratedDokployRuntime(rpcCall),
-                helpers: buildHelpers(),
-            };
+            : (() => {
+                const rpcExecutor = async (procedure, input) => {
+                    const data = await rpcCall(procedure, input ?? {});
+                    return {
+                        data: data,
+                        trace: {
+                            procedure,
+                            method: 'GET',
+                            startedAt: Date.now(),
+                            finishedAt: Date.now(),
+                            durationMs: 0,
+                        },
+                    };
+                };
+                const maxCalls = limits?.maxCalls ?? resolveSandboxLimits().maxCalls;
+                const ctx = createExecuteContext(rpcExecutor, maxCalls);
+                return {
+                    dokploy: ctx.dokploy,
+                    helpers: ctx.helpers,
+                };
+            })();
         const execution = await runSandboxedFunction({
             code: String(payload.code),
             context,