@fndchagas/coolify-mcp 0.1.1 → 0.1.3

package/README.md

@@ -1,20 +1,20 @@
 # coolify-mcp
 
-MCP server for Coolify, pinned to a specific Coolify OpenAPI version.
+MCP server for Coolify API.
 
-## Pinned Coolify version
+## Pinned Coolify Version
 
-This repo is pinned to:
+Version is defined in `src/coolify/constants.ts`. To update:
 
-- `v4.0.0-beta.460`
-- OpenAPI file: `openapi/coolify/v4.0.0-beta.460.json`
+1. Edit `COOLIFY_VERSION` in `src/coolify/constants.ts`
+2. Run `npm run update`
 
 ## Requirements
 
 - Node 18+
 - A Coolify API token
 
-## Install (package)
+## Install
 
 ```bash
 npm install -g @fndchagas/coolify-mcp
@@ -22,7 +22,7 @@ npm install -g @fndchagas/coolify-mcp
 npx -y @fndchagas/coolify-mcp
 ```
 
-## Use with Claude Code CLI (stdio)
+## Use with Claude Code CLI
 
 ```bash
 claude mcp add coolify \
@@ -31,13 +31,13 @@ claude mcp add coolify \
   -- npx -y @fndchagas/coolify-mcp
 ```
 
-Optional: disable write tools (deploy/upsert) by adding:
+Disable write tools (deploy/env mutations):
 
 ```bash
 --env COOLIFY_ALLOW_WRITE=false
 ```
 
-## Use with OpenAI Codex CLI (stdio)
+## Use with OpenAI Codex CLI
 
 ```bash
 codex mcp add coolify \
@@ -55,70 +55,51 @@ args = ["-y", "@fndchagas/coolify-mcp"]
 env = { COOLIFY_BASE_URL = "https://coolify.example.com", COOLIFY_TOKEN = "<token>" }
 ```
 
-## Install (dev)
+## Development
 
 ```bash
 npm install
-```
-
-## Generate types (if OpenAPI changes)
-
-```bash
-npm run generate:openapi
-```
-
-## Run (stdio)
-
-```bash
-COOLIFY_BASE_URL="https://coolify.example.com" \
-COOLIFY_TOKEN="<token>" \
-MCP_TRANSPORT=stdio \
 npm run dev
 ```
 
-## Run (HTTP)
+## Scripts
 
 ```bash
-COOLIFY_BASE_URL="https://coolify.example.com" \
-COOLIFY_TOKEN="<token>" \
-MCP_TRANSPORT=http \
-PORT=7331 \
-npm run dev
+npm run dev            # Run in development mode
+npm run build          # Build TypeScript
+npm run generate       # Regenerate types from OpenAPI
+npm run fetch:openapi  # Fetch latest OpenAPI spec
+npm run update         # Fetch + regenerate
 ```
 
-Endpoint: `POST http://localhost:7331/mcp`
+## Environment Variables
 
-## Run (both)
-
-```bash
-MCP_TRANSPORT=both npm run dev
-```
-
-## Environment variables
-
-- `COOLIFY_BASE_URL` (required)
-- `COOLIFY_TOKEN` (required)
-- `COOLIFY_OPENAPI_REF` (default: `v4.0.0-beta.460`)
-- `COOLIFY_STRICT_VERSION` (default: `false`)
-- `COOLIFY_ALLOW_WRITE` (default: `true`)
-- `MCP_TRANSPORT` (`stdio`, `http`, `both`)
-- `PORT` (HTTP port, default `7331`)
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `COOLIFY_BASE_URL` | required | Coolify API URL |
+| `COOLIFY_TOKEN` | required | API token |
+| `COOLIFY_STRICT_VERSION` | `false` | Fail on version mismatch |
+| `COOLIFY_ALLOW_WRITE` | `true` | Enable write operations |
+| `MCP_TRANSPORT` | `stdio` | Transport: `stdio`, `http`, `both` |
+| `PORT` | `7331` | HTTP port |
 
 ## Tools
 
 - `coolify.listResources`
+- `coolify.listApplications`
 - `coolify.getApplication`
+- `coolify.getLogs`
 - `coolify.listEnvs`
-- `coolify.upsertEnv`
+- `coolify.createEnv`
+- `coolify.updateEnv`
 - `coolify.deploy`
 - `coolify.getDeployment`
-- `coolify.getLogs`
 - `coolify.listDatabases`
 - `coolify.getDatabase`
 
-## MCP usage examples
+## MCP Usage Examples
 
-### HTTP client (Streamable HTTP)
+### HTTP Client
 
 ```ts
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -131,31 +112,21 @@ const transport = new StreamableHTTPClientTransport(
 
 await client.connect(transport);
 
-const tools = await client.listTools();
-console.log(tools.tools.map((t) => t.name));
-
 const resources = await client.callTool({
   name: 'coolify.listResources',
   arguments: {},
 });
 console.log(resources.structuredContent);
 
-const logs = await client.callTool({
-  name: 'coolify.getLogs',
-  arguments: { appUuid: 'nwggo800g800oosow8ks4c88' },
-});
-console.log(logs.structuredContent);
-
 await client.close();
 ```
 
-### Stdio client (spawn server)
+### Stdio Client
 
 ```ts
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 
-// Ensure COOLIFY_BASE_URL and COOLIFY_TOKEN are set in the environment
 const client = new Client({ name: 'coolify-client', version: '1.0.0' });
 const transport = new StdioClientTransport({
   command: 'node',
@@ -166,7 +137,7 @@ await client.connect(transport);
 
 const result = await client.callTool({
   name: 'coolify.getApplication',
-  arguments: { uuid: 'nwggo800g800oosow8ks4c88' },
+  arguments: { uuid: 'your-app-uuid' },
 });
 console.log(result.structuredContent);
 

package/dist/config.js

@@ -1,6 +1,7 @@
+import { COOLIFY_VERSION } from './coolify/constants.js';
 export const COOLIFY_BASE_URL = process.env.COOLIFY_BASE_URL;
 export const COOLIFY_TOKEN = process.env.COOLIFY_TOKEN;
-export const COOLIFY_OPENAPI_REF = process.env.COOLIFY_OPENAPI_REF ?? 'v4.0.0-beta.460';
+export const COOLIFY_OPENAPI_REF = process.env.COOLIFY_OPENAPI_REF ?? COOLIFY_VERSION;
 export const MCP_TRANSPORT = process.env.MCP_TRANSPORT ?? 'stdio';
 export const MCP_HTTP_PORT = Number(process.env.PORT ?? '7331');
 export const COOLIFY_STRICT_VERSION = process.env.COOLIFY_STRICT_VERSION === 'true';

package/dist/coolify/client.js

@@ -1,53 +1,16 @@
 import { COOLIFY_BASE_URL, COOLIFY_TOKEN } from '../config.js';
-function requireEnv(value, name) {
-    if (!value) {
-        throw new Error(`${name} is required`);
+import { client } from '../generated/client.gen.js';
+export function initializeClient() {
+    if (!COOLIFY_BASE_URL) {
+        throw new Error('COOLIFY_BASE_URL is required');
     }
-    return value;
-}
-function buildUrl(path, query) {
-    const base = requireEnv(COOLIFY_BASE_URL, 'COOLIFY_BASE_URL');
-    const url = new URL(path, base);
-    if (query) {
-        for (const [key, value] of Object.entries(query)) {
-            if (value !== undefined) {
-                url.searchParams.set(key, value);
-            }
-        }
-    }
-    return url.toString();
-}
-export async function request(method, path, options) {
-    const token = requireEnv(COOLIFY_TOKEN, 'COOLIFY_TOKEN');
-    const url = buildUrl(path, options?.query);
-    const headers = {
-        Authorization: `Bearer ${token}`,
-        Accept: 'application/json',
-    };
-    let body;
-    if (options?.body !== undefined) {
-        headers['Content-Type'] = 'application/json';
-        body = JSON.stringify(options.body);
-    }
-    const response = await fetch(url, { method, headers, body });
-    const contentType = response.headers.get('content-type') ?? '';
-    if (!response.ok) {
-        const text = await response.text();
-        throw new Error(`Coolify API error ${response.status}: ${text || response.statusText}`);
-    }
-    if (contentType.includes('application/json')) {
-        return (await response.json());
-    }
-    return (await response.text());
-}
-export async function getVersion() {
-    const data = await request('GET', '/api/v1/version');
-    if (typeof data === 'string') {
-        return data.trim();
-    }
-    if (data && typeof data === 'object' && 'version' in data) {
-        const version = data.version;
-        return version ?? 'unknown';
+    if (!COOLIFY_TOKEN) {
+        throw new Error('COOLIFY_TOKEN is required');
     }
-    return 'unknown';
+    client.setConfig({
+        baseUrl: COOLIFY_BASE_URL,
+        headers: {
+            Authorization: `Bearer ${COOLIFY_TOKEN}`,
+        },
+    });
 }

package/dist/coolify/constants.js

@@ -0,0 +1,3 @@
+export const COOLIFY_VERSION = "v4.0.0-beta.460";
+const COOLIFY_REPO = "coollabsio/coolify";
+export const COOLIFY_OPENAPI_RAW_URL = `https://raw.githubusercontent.com/${COOLIFY_REPO}/${COOLIFY_VERSION}/openapi.json`;

package/dist/generated/client/client.gen.js

@@ -0,0 +1,229 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createSseClient } from '../core/serverSentEvents.gen.js';
+import { getValidRequestBody } from '../core/utils.gen.js';
+import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from './utils.gen.js';
+export const createClient = (config = {}) => {
+    let _config = mergeConfigs(createConfig(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = mergeConfigs(_config, config);
+        return getConfig();
+    };
+    const interceptors = createInterceptors();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: mergeHeaders(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await setAuthParams({
+                ...opts,
+                security: opts.security,
+            });
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body !== undefined && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.body === undefined || opts.serializedBody === '') {
+            opts.headers.delete('Content-Type');
+        }
+        const url = buildUrl(opts);
+        return { opts, url };
+    };
+    const request = async (options) => {
+        // @ts-expect-error
+        const { opts, url } = await beforeRequest(options);
+        const requestInit = {
+            redirect: 'follow',
+            ...opts,
+            body: getValidRequestBody(opts),
+        };
+        let request = new Request(url, requestInit);
+        for (const fn of interceptors.request.fns) {
+            if (fn) {
+                request = await fn(request, opts);
+            }
+        }
+        // fetch must be assigned here, otherwise it would throw the error:
+        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+        const _fetch = opts.fetch;
+        let response;
+        try {
+            response = await _fetch(request);
+        }
+        catch (error) {
+            // Handle fetch exceptions (AbortError, network errors, etc.)
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = (await fn(error, undefined, request, opts));
+                }
+            }
+            finalError = finalError || {};
+            if (opts.throwOnError) {
+                throw finalError;
+            }
+            // Return error response
+            return opts.responseStyle === 'data'
+                ? undefined
+                : {
+                    error: finalError,
+                    request,
+                    response: undefined,
+                };
+        }
+        for (const fn of interceptors.response.fns) {
+            if (fn) {
+                response = await fn(response, request, opts);
+            }
+        }
+        const result = {
+            request,
+            response,
+        };
+        if (response.ok) {
+            const parseAs = (opts.parseAs === 'auto'
+                ? getParseAs(response.headers.get('Content-Type'))
+                : opts.parseAs) ?? 'json';
+            if (response.status === 204 ||
+                response.headers.get('Content-Length') === '0') {
+                let emptyData;
+                switch (parseAs) {
+                    case 'arrayBuffer':
+                    case 'blob':
+                    case 'text':
+                        emptyData = await response[parseAs]();
+                        break;
+                    case 'formData':
+                        emptyData = new FormData();
+                        break;
+                    case 'stream':
+                        emptyData = response.body;
+                        break;
+                    case 'json':
+                    default:
+                        emptyData = {};
+                        break;
+                }
+                return opts.responseStyle === 'data'
+                    ? emptyData
+                    : {
+                        data: emptyData,
+                        ...result,
+                    };
+            }
+            let data;
+            switch (parseAs) {
+                case 'arrayBuffer':
+                case 'blob':
+                case 'formData':
+                case 'json':
+                case 'text':
+                    data = await response[parseAs]();
+                    break;
+                case 'stream':
+                    return opts.responseStyle === 'data'
+                        ? response.body
+                        : {
+                            data: response.body,
+                            ...result,
+                        };
+            }
+            if (parseAs === 'json') {
+                if (opts.responseValidator) {
+                    await opts.responseValidator(data);
+                }
+                if (opts.responseTransformer) {
+                    data = await opts.responseTransformer(data);
+                }
+            }
+            return opts.responseStyle === 'data'
+                ? data
+                : {
+                    data,
+                    ...result,
+                };
+        }
+        const textError = await response.text();
+        let jsonError;
+        try {
+            jsonError = JSON.parse(textError);
+        }
+        catch {
+            // noop
+        }
+        const error = jsonError ?? textError;
+        let finalError = error;
+        for (const fn of interceptors.error.fns) {
+            if (fn) {
+                finalError = (await fn(error, response, request, opts));
+            }
+        }
+        finalError = finalError || {};
+        if (opts.throwOnError) {
+            throw finalError;
+        }
+        // TODO: we probably want to return error and improve types
+        return opts.responseStyle === 'data'
+            ? undefined
+            : {
+                error: finalError,
+                ...result,
+            };
+    };
+    const makeMethodFn = (method) => (options) => request({ ...options, method });
+    const makeSseFn = (method) => async (options) => {
+        const { opts, url } = await beforeRequest(options);
+        return createSseClient({
+            ...opts,
+            body: opts.body,
+            headers: opts.headers,
+            method,
+            onRequest: async (url, init) => {
+                let request = new Request(url, init);
+                for (const fn of interceptors.request.fns) {
+                    if (fn) {
+                        request = await fn(request, opts);
+                    }
+                }
+                return request;
+            },
+            serializedBody: getValidRequestBody(opts),
+            url,
+        });
+    };
+    return {
+        buildUrl,
+        connect: makeMethodFn('CONNECT'),
+        delete: makeMethodFn('DELETE'),
+        get: makeMethodFn('GET'),
+        getConfig,
+        head: makeMethodFn('HEAD'),
+        interceptors,
+        options: makeMethodFn('OPTIONS'),
+        patch: makeMethodFn('PATCH'),
+        post: makeMethodFn('POST'),
+        put: makeMethodFn('PUT'),
+        request,
+        setConfig,
+        sse: {
+            connect: makeSseFn('CONNECT'),
+            delete: makeSseFn('DELETE'),
+            get: makeSseFn('GET'),
+            head: makeSseFn('HEAD'),
+            options: makeSseFn('OPTIONS'),
+            patch: makeSseFn('PATCH'),
+            post: makeSseFn('POST'),
+            put: makeSseFn('PUT'),
+            trace: makeSseFn('TRACE'),
+        },
+        trace: makeMethodFn('TRACE'),
+    };
+};

package/dist/generated/client/index.js

@@ -0,0 +1,6 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen.js';
+export { buildClientParams } from '../core/params.gen.js';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen.js';
+export { createClient } from './client.gen.js';
+export { createConfig, mergeHeaders } from './utils.gen.js';

package/dist/generated/client/types.gen.js

@@ -0,0 +1,2 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export {};