@vibetools/dokploy-mcp 0.4.0

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+const args = process.argv.slice(2);
+if (args.length > 0) {
+    // CLI mode - handle subcommands
+    import('./cli/index.js')
+        .then(({ runCli }) => runCli(args))
+        .catch((err) => {
+        console.error('Error:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    });
+}
+else {
+    // MCP server mode - start stdio transport
+    Promise.all([import('@modelcontextprotocol/sdk/server/stdio.js'), import('./server.js')])
+        .then(async ([{ StdioServerTransport }, { createServer }]) => {
+        const server = createServer();
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+    })
+        .catch((err) => {
+        console.error('Fatal error:', err);
+        process.exit(1);
+    });
+}
+export {};

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,17 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { allTools } from './tools/index.js';
+export function createServer() {
+    const server = new McpServer({
+        name: 'dokploy-mcp-server',
+        version: '0.1.0',
+    });
+    for (const tool of allTools) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.schema,
+            annotations: tool.annotations,
+        }, tool.handler);
+    }
+    return server;
+}

package/dist/tools/_factory.d.ts

@@ -0,0 +1,53 @@
+import type { ZodObject, z } from 'zod';
+import { api } from '../api/client.js';
+type AnyZodObject = ZodObject;
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface ToolDefinition {
+    name: string;
+    title: string;
+    description: string;
+    schema: AnyZodObject;
+    annotations: ToolAnnotations;
+    handler: (input: Record<string, unknown>) => Promise<{
+        content: {
+            type: 'text';
+            text: string;
+        }[];
+        structuredContent?: Record<string, unknown>;
+        isError?: boolean;
+    }>;
+}
+export declare function createTool<T extends AnyZodObject>(def: {
+    name: string;
+    title: string;
+    description: string;
+    schema: T;
+    annotations: ToolAnnotations;
+    handler: (params: {
+        input: z.infer<T>;
+        api: typeof api;
+    }) => Promise<unknown>;
+}): ToolDefinition;
+export declare function postTool<T extends AnyZodObject>(opts: {
+    name: string;
+    title: string;
+    description: string;
+    schema: T;
+    endpoint: string;
+    annotations?: Partial<ToolAnnotations>;
+}): ToolDefinition;
+export declare function getTool<T extends AnyZodObject>(opts: {
+    name: string;
+    title: string;
+    description: string;
+    schema: T;
+    endpoint: string;
+    annotations?: Partial<ToolAnnotations>;
+}): ToolDefinition;
+export {};

package/dist/tools/_factory.js

@@ -0,0 +1,86 @@
+import { ApiError, api } from '../api/client.js';
+function success(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        structuredContent: data,
+    };
+}
+function error(message, details) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({ error: message, ...(details ? { details } : {}) }, null, 2),
+            },
+        ],
+        isError: true,
+    };
+}
+function mapApiError(err) {
+    switch (err.status) {
+        case 401:
+            return error('Authentication failed', 'Check your DOKPLOY_API_KEY environment variable.');
+        case 403:
+            return error('Permission denied', 'Your API key lacks permission for this operation.');
+        case 404:
+            return error('Resource not found', err.message);
+        case 422:
+            return error('Validation error', typeof err.body === 'object' && err.body !== null ? JSON.stringify(err.body) : err.message);
+        default:
+            return error(`Dokploy API error (${err.status})`, err.message);
+    }
+}
+export function createTool(def) {
+    return {
+        name: def.name,
+        title: def.title,
+        description: def.description,
+        schema: def.schema,
+        annotations: { openWorldHint: true, ...def.annotations },
+        handler: async (input) => {
+            try {
+                const result = await def.handler({ input: input, api });
+                return success(result);
+            }
+            catch (err) {
+                if (err instanceof ApiError) {
+                    return mapApiError(err);
+                }
+                return error(`Failed to execute ${def.name}`, err instanceof Error ? err.message : 'Unknown error');
+            }
+        },
+    };
+}
+export function postTool(opts) {
+    return createTool({
+        name: opts.name,
+        title: opts.title,
+        description: opts.description,
+        schema: opts.schema,
+        annotations: { openWorldHint: true, ...opts.annotations },
+        handler: async ({ input, api }) => api.post(opts.endpoint, input),
+    });
+}
+export function getTool(opts) {
+    return createTool({
+        name: opts.name,
+        title: opts.title,
+        description: opts.description,
+        schema: opts.schema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+            ...opts.annotations,
+        },
+        handler: async ({ input, api }) => {
+            const params = {};
+            for (const [k, v] of Object.entries(input)) {
+                if (v !== undefined && v !== null) {
+                    params[k] = v;
+                }
+            }
+            return api.get(opts.endpoint, Object.keys(params).length > 0 ? params : undefined);
+        },
+    });
+}

package/dist/tools/admin.d.ts

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

package/dist/tools/admin.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { postTool } from './_factory.js';
+// ── tools ────────────────────────────────────────────────────────────
+const setupMonitoring = postTool({
+    name: 'dokploy_admin_setup_monitoring',
+    title: 'Setup Monitoring',
+    description: 'Configure server and container monitoring metrics. Sets up refresh rates, retention policies, callback URLs, resource thresholds, and container service filters for the monitoring system.',
+    schema: z
+        .object({
+        metricsConfig: z
+            .object({
+            server: z
+                .object({
+                refreshRate: z
+                    .number()
+                    .min(2)
+                    .describe('Metrics refresh rate in seconds (minimum 2)'),
+                port: z.number().min(1).describe('Monitoring port number'),
+                token: z.string().describe('Authentication token for metrics endpoint'),
+                urlCallback: z.string().url().describe('Callback URL for metrics data'),
+                retentionDays: z.number().min(1).describe('Number of days to retain metrics data'),
+                cronJob: z
+                    .string()
+                    .min(1)
+                    .describe('Cron expression for scheduled metrics collection'),
+                thresholds: z
+                    .object({
+                    cpu: z.number().min(0).describe('CPU usage threshold percentage'),
+                    memory: z.number().min(0).describe('Memory usage threshold percentage'),
+                })
+                    .strict(),
+            })
+                .strict(),
+            containers: z
+                .object({
+                refreshRate: z
+                    .number()
+                    .min(2)
+                    .describe('Container metrics refresh rate in seconds (minimum 2)'),
+                services: z
+                    .object({
+                    include: z
+                        .array(z.string())
+                        .optional()
+                        .describe('Service names to include in monitoring'),
+                    exclude: z
+                        .array(z.string())
+                        .optional()
+                        .describe('Service names to exclude from monitoring'),
+                })
+                    .strict(),
+            })
+                .strict(),
+        })
+            .strict(),
+    })
+        .strict(),
+    endpoint: '/admin.setupMonitoring',
+});
+// ── export ───────────────────────────────────────────────────────────
+export const adminTools = [setupMonitoring];

package/dist/tools/application.d.ts

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