@masonator/coolify-mcp 2.7.3 → 2.8.1

package/README.md

@@ -85,6 +85,34 @@ claude mcp add coolify \
 env COOLIFY_ACCESS_TOKEN=your-api-token COOLIFY_BASE_URL=https://your-coolify-instance.com npx -y @masonator/coolify-mcp
 ```
 
+### Custom HTTP Headers (Cloudflare Zero Trust, Auth Proxies)
+
+If your Coolify instance sits behind a Cloudflare Access tunnel or other auth-proxy middleware, pass extra headers on every outbound request with `--header`:
+
+```json
+{
+  "mcpServers": {
+    "coolify": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@masonator/coolify-mcp",
+        "--header",
+        "CF-Access-Client-Id: abc123.access",
+        "--header",
+        "CF-Access-Client-Secret: your-secret"
+      ],
+      "env": {
+        "COOLIFY_ACCESS_TOKEN": "your-api-token",
+        "COOLIFY_BASE_URL": "https://your-coolify-instance.com"
+      }
+    }
+  }
+}
+```
+
+Multiple `--header` flags can be combined. The reserved headers `Authorization` and `Content-Type` are filtered (with a warning) to prevent silently overriding the Coolify bearer token.
+
 ## Context-Optimized Responses
 
 ### Why This Matters
@@ -103,13 +131,14 @@ The Coolify API returns extremely verbose responses - a single application can c
 
 ### Response Size Comparison
 
-| Endpoint              | Full Response | Summary Response | Reduction |
-| --------------------- | ------------- | ---------------- | --------- |
-| list_applications     | ~170KB        | ~4.4KB           | **97%**   |
-| list_services         | ~367KB        | ~1.2KB           | **99%**   |
-| list_servers          | ~4KB          | ~0.4KB           | **90%**   |
-| list_application_envs | ~3KB/var      | ~0.1KB/var       | **97%**   |
-| deployment get        | ~13KB         | ~1KB             | **92%**   |
+| Endpoint                | Full Response | Summary Response | Reduction |
+| ----------------------- | ------------- | ---------------- | --------- |
+| list_applications       | ~170KB        | ~4.4KB           | **97%**   |
+| list_services           | ~367KB        | ~1.2KB           | **99%**   |
+| list_servers            | ~4KB          | ~0.4KB           | **90%**   |
+| list_application_envs   | ~3KB/var      | ~0.1KB/var       | **97%**   |
+| deployment get          | ~13KB         | ~1KB             | **92%**   |
+| deployment list_for_app | ~1MB          | ~4KB             | **99.6%** |
 
 ### HATEOAS-style Response Actions
 

package/dist/__tests__/coolify-client.test.js

@@ -126,6 +126,42 @@ describe('CoolifyClient', () => {
             c.getVersion();
             expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/version', expect.any(Object));
         });
+        it('should merge customHeaders into outgoing requests', async () => {
+            const c = new CoolifyClient({
+                baseUrl: 'http://localhost:3000',
+                accessToken: 'test-token',
+                customHeaders: { 'CF-Access-Client-Id': 'abc', 'CF-Access-Client-Secret': 'xyz' },
+            });
+            mockFetch.mockResolvedValueOnce(mockResponse([{ uuid: 's1', name: 'srv' }]));
+            await c.listServers();
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                headers: expect.objectContaining({
+                    'CF-Access-Client-Id': 'abc',
+                    'CF-Access-Client-Secret': 'xyz',
+                    Authorization: 'Bearer test-token',
+                }),
+            }));
+        });
+        it('should filter reserved headers from customHeaders', async () => {
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+            const c = new CoolifyClient({
+                baseUrl: 'http://localhost:3000',
+                accessToken: 'test-token',
+                customHeaders: {
+                    Authorization: 'Bearer override',
+                    'Content-Type': 'text/plain',
+                    'X-Safe-Header': 'allowed',
+                },
+            });
+            mockFetch.mockResolvedValueOnce(mockResponse([{ uuid: 's1', name: 'srv' }]));
+            await c.listServers();
+            const headers = mockFetch.mock.calls[0][1]?.headers;
+            expect(headers['Authorization']).toBe('Bearer test-token');
+            expect(headers['Content-Type']).toBe('application/json');
+            expect(headers['X-Safe-Header']).toBe('allowed');
+            expect(warnSpy).toHaveBeenCalledTimes(2);
+            warnSpy.mockRestore();
+        });
     });
     describe('listServers', () => {
         it('should return a list of servers', async () => {
@@ -849,6 +885,87 @@ describe('CoolifyClient', () => {
             expect(callBody.domains).toBe('https://app.example.com');
             expect(callBody.fqdn).toBeUndefined();
         });
+        it('should map fqdn to domains in createApplicationDockerImage', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'new-app-uuid' }));
+            await client.createApplicationDockerImage({
+                project_uuid: 'proj-uuid',
+                server_uuid: 'server-uuid',
+                docker_registry_image_name: 'traefik/whoami',
+                ports_exposes: '80',
+                fqdn: 'https://whoami.example.com',
+            });
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1]?.body);
+            expect(callBody.domains).toBe('https://whoami.example.com');
+            expect(callBody.fqdn).toBeUndefined();
+        });
+        it('should map fqdn to domains in createApplicationDockerfile', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'new-app-uuid' }));
+            await client.createApplicationDockerfile({
+                project_uuid: 'proj-uuid',
+                server_uuid: 'server-uuid',
+                dockerfile: 'FROM nginx',
+                fqdn: 'https://app.example.com',
+            });
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1]?.body);
+            expect(callBody.domains).toBe('https://app.example.com');
+            expect(callBody.fqdn).toBeUndefined();
+        });
+        it('should map fqdn to domains in createApplicationDockerCompose', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'new-app-uuid' }));
+            await client.createApplicationDockerCompose({
+                project_uuid: 'proj-uuid',
+                server_uuid: 'server-uuid',
+                docker_compose_raw: 'version: "3"\n',
+                fqdn: 'https://compose.example.com',
+            });
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1]?.body);
+            expect(callBody.domains).toBe('https://compose.example.com');
+            expect(callBody.fqdn).toBeUndefined();
+        });
+        it('should accept explicit domains and prefer it over fqdn', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'new-app-uuid' }));
+            await client.createApplicationDockerImage({
+                project_uuid: 'proj-uuid',
+                server_uuid: 'server-uuid',
+                docker_registry_image_name: 'traefik/whoami',
+                ports_exposes: '80',
+                fqdn: 'https://from-fqdn.example.com',
+                domains: 'https://from-domains.example.com',
+            });
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1]?.body);
+            expect(callBody.domains).toBe('https://from-domains.example.com');
+            expect(callBody.fqdn).toBeUndefined();
+        });
+        it('should pass instant_deploy and custom_* fields through createApplicationDockerImage', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'new-app-uuid' }));
+            await client.createApplicationDockerImage({
+                project_uuid: 'proj-uuid',
+                server_uuid: 'server-uuid',
+                docker_registry_image_name: 'traefik/whoami',
+                ports_exposes: '80',
+                instant_deploy: true,
+                custom_docker_run_options: '--network=my-net',
+                custom_labels: 'dHJhZWZpaw==',
+            });
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1]?.body);
+            expect(callBody.instant_deploy).toBe(true);
+            expect(callBody.custom_docker_run_options).toBe('--network=my-net');
+            expect(callBody.custom_labels).toBe('dHJhZWZpaw==');
+        });
+        it('should pass destination_uuid through in createApplicationPublic', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'new-app-uuid' }));
+            await client.createApplicationPublic({
+                project_uuid: 'proj-uuid',
+                server_uuid: 'server-uuid',
+                destination_uuid: 'dest-uuid',
+                git_repository: 'https://github.com/user/repo',
+                git_branch: 'main',
+                build_pack: 'nixpacks',
+                ports_exposes: '3000',
+            });
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1]?.body);
+            expect(callBody.destination_uuid).toBe('dest-uuid');
+        });
         it('should map fqdn to domains in updateApplication', async () => {
             mockFetch.mockResolvedValueOnce(mockResponse(mockApplication));
             await client.updateApplication('app-uuid', { fqdn: 'https://new.example.com' });
@@ -1457,12 +1574,32 @@ describe('CoolifyClient', () => {
                 logs_info: 'Logs available (16 chars). Use lines param to retrieve.',
             });
         });
-        it('should list application deployments', async () => {
-            mockFetch.mockResolvedValueOnce(mockResponse([mockDeployment]));
+        it('should list application deployments as essential by default (no logs)', async () => {
+            const withLogs = { ...mockDeployment, logs: 'x'.repeat(30000) };
+            // Real Coolify wraps the list in an envelope: { count, deployments: [...] }
+            mockFetch.mockResolvedValueOnce(mockResponse({ count: 1, deployments: [withLogs] }));
             const result = await client.listApplicationDeployments('app-uuid');
-            expect(result).toEqual([mockDeployment]);
+            expect(result.count).toBe(1);
+            expect(result.deployments).toHaveLength(1);
+            const [first] = result.deployments;
+            // Essential projection: no raw logs, but a `logs_available` breadcrumb.
+            expect(first.logs).toBeUndefined();
+            expect(first.logs_available).toBe(true);
+            // Essential also drops fields like `id`
+            expect(first.id).toBeUndefined();
             expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/deployments/applications/app-uuid', expect.any(Object));
         });
+        it('should return full deployments when includeLogs is true', async () => {
+            const withLogs = { ...mockDeployment, logs: 'build log stream' };
+            mockFetch.mockResolvedValueOnce(mockResponse({ count: 1, deployments: [withLogs] }));
+            const result = await client.listApplicationDeployments('app-uuid', { includeLogs: true });
+            expect(result).toEqual({ count: 1, deployments: [withLogs] });
+        });
+        it('should tolerate a malformed envelope (missing deployments array)', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({}));
+            const result = await client.listApplicationDeployments('app-uuid');
+            expect(result).toEqual({ count: 0, deployments: [] });
+        });
     });
     // =========================================================================
     // Team endpoints - extended coverage
@@ -1906,7 +2043,7 @@ describe('CoolifyClient', () => {
                     .mockResolvedValueOnce(mockResponse(mockApp))
                     .mockResolvedValueOnce(mockResponse(mockLogs))
                     .mockResolvedValueOnce(mockResponse(mockEnvVars))
-                    .mockResolvedValueOnce(mockResponse(mockDeployments));
+                    .mockResolvedValueOnce(mockResponse({ count: mockDeployments.length, deployments: mockDeployments }));
                 const result = await client.diagnoseApplication(testAppUuid);
                 expect(result.application).toEqual({
                     uuid: testAppUuid,
@@ -1932,7 +2069,7 @@ describe('CoolifyClient', () => {
                     .mockResolvedValueOnce(mockResponse(unhealthyApp))
                     .mockResolvedValueOnce(mockResponse(mockLogs))
                     .mockResolvedValueOnce(mockResponse(mockEnvVars))
-                    .mockResolvedValueOnce(mockResponse([]));
+                    .mockResolvedValueOnce(mockResponse({ count: 0, deployments: [] }));
                 const result = await client.diagnoseApplication(testAppUuid);
                 expect(result.health.status).toBe('unhealthy');
                 expect(result.health.issues).toContain('Status: exited:unhealthy');
@@ -1946,7 +2083,7 @@ describe('CoolifyClient', () => {
                     .mockResolvedValueOnce(mockResponse(mockApp))
                     .mockResolvedValueOnce(mockResponse(mockLogs))
                     .mockResolvedValueOnce(mockResponse(mockEnvVars))
-                    .mockResolvedValueOnce(mockResponse(failedDeployments));
+                    .mockResolvedValueOnce(mockResponse({ count: failedDeployments.length, deployments: failedDeployments }));
                 const result = await client.diagnoseApplication(testAppUuid);
                 expect(result.health.issues).toContain('2 failed deployment(s) in last 5');
             });
@@ -1955,7 +2092,7 @@ describe('CoolifyClient', () => {
                     .mockResolvedValueOnce(mockResponse(mockApp))
                     .mockRejectedValueOnce(new Error('Logs unavailable'))
                     .mockResolvedValueOnce(mockResponse(mockEnvVars))
-                    .mockResolvedValueOnce(mockResponse(mockDeployments));
+                    .mockResolvedValueOnce(mockResponse({ count: mockDeployments.length, deployments: mockDeployments }));
                 const result = await client.diagnoseApplication(testAppUuid);
                 expect(result.application).not.toBeNull();
                 expect(result.logs).toBeNull();

package/dist/__tests__/parse-headers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/parse-headers.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect } from '@jest/globals';
+import { parseHeaders } from '../lib/parse-headers.js';
+describe('parseHeaders', () => {
+    it('should parse a single header', () => {
+        const result = parseHeaders(['--header', 'X-Custom: value']);
+        expect(result).toEqual({ 'X-Custom': 'value' });
+    });
+    it('should parse multiple headers', () => {
+        const result = parseHeaders(['--header', 'X-First: one', '--header', 'X-Second: two']);
+        expect(result).toEqual({ 'X-First': 'one', 'X-Second': 'two' });
+    });
+    it('should ignore malformed headers without a colon', () => {
+        const result = parseHeaders(['--header', 'no-colon-here']);
+        expect(result).toEqual({});
+    });
+    it('should trim whitespace from key and value', () => {
+        const result = parseHeaders(['--header', '  X-Spaced  :  some value  ']);
+        expect(result).toEqual({ 'X-Spaced': 'some value' });
+    });
+    it('should handle header value containing colons', () => {
+        const result = parseHeaders(['--header', 'Authorization: Bearer abc:def:ghi']);
+        expect(result).toEqual({ Authorization: 'Bearer abc:def:ghi' });
+    });
+    it('should return empty object when no headers provided', () => {
+        expect(parseHeaders([])).toEqual({});
+        expect(parseHeaders(['--other', 'flag'])).toEqual({});
+    });
+    it('should ignore --header without a following value', () => {
+        const result = parseHeaders(['--header']);
+        expect(result).toEqual({});
+    });
+});

package/dist/index.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CoolifyMcpServer } from './lib/mcp-server.js';
+import { parseHeaders } from './lib/parse-headers.js';
 async function main() {
+    const customHeaders = parseHeaders(process.argv);
     const config = {
         baseUrl: process.env.COOLIFY_BASE_URL || 'http://localhost:3000',
         accessToken: process.env.COOLIFY_ACCESS_TOKEN || '',
+        customHeaders: Object.keys(customHeaders).length > 0 ? customHeaders : undefined,
     };
     if (!config.accessToken) {
         throw new Error('COOLIFY_ACCESS_TOKEN environment variable is required');

package/dist/lib/coolify-client.d.ts

@@ -72,6 +72,7 @@ export interface GitHubAppSummary {
 export declare class CoolifyClient {
     private readonly baseUrl;
     private readonly accessToken;
+    private readonly customHeaders;
     private cachedVersion;
     constructor(config: CoolifyConfig);
     private request;
@@ -163,7 +164,23 @@ export declare class CoolifyClient {
         includeLogs?: boolean;
     }): Promise<Deployment | DeploymentEssential>;
     deployByTagOrUuid(tagOrUuid: string, force?: boolean): Promise<MessageResponse>;
-    listApplicationDeployments(appUuid: string): Promise<Deployment[]>;
+    /**
+     * List deployments for an application.
+     *
+     * Coolify returns `{ count, deployments: Deployment[] }` for this endpoint
+     * (NOT a raw array — upstream @masonator type was incorrect).
+     *
+     * By default returns a DeploymentEssential summary (no `logs` field) because
+     * each deployment's log blob can be 30–100KB, and a typical list has 20–35
+     * deployments — exceeding MCP response token limits. Pass `includeLogs: true`
+     * to get raw Deployment objects with full build logs.
+     */
+    listApplicationDeployments(appUuid: string, options?: {
+        includeLogs?: boolean;
+    }): Promise<{
+        count: number;
+        deployments: Deployment[] | DeploymentEssential[];
+    }>;
     listTeams(): Promise<Team[]>;
     getTeam(id: number): Promise<Team>;
     getTeamMembers(id: number): Promise<TeamMember[]>;

package/dist/lib/coolify-client.js

@@ -35,6 +35,12 @@ function toBase64(value) {
  */
 function mapFqdnToDomains(data) {
     const { fqdn, ...rest } = data;
+    // Explicit `domains` always wins. `fqdn` is only used when `domains` was
+    // not provided — kept for backward compatibility because `get_application`
+    // surfaces the field as `fqdn` in responses.
+    if (rest.domains !== undefined) {
+        return rest;
+    }
     if (fqdn === undefined) {
         return rest;
     }
@@ -143,8 +149,11 @@ function toEnvVarSummary(envVar) {
  * HTTP client for the Coolify API
  */
 export class CoolifyClient {
+    baseUrl;
+    accessToken;
+    customHeaders;
+    cachedVersion = null;
     constructor(config) {
-        this.cachedVersion = null;
         if (!config.baseUrl) {
             throw new Error('Coolify base URL is required');
         }
@@ -153,6 +162,18 @@ export class CoolifyClient {
         }
         this.baseUrl = config.baseUrl.replace(/\/$/, '');
         this.accessToken = config.accessToken;
+        const reserved = new Set(['authorization', 'content-type']);
+        const raw = config.customHeaders ?? {};
+        const filtered = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (reserved.has(key.toLowerCase())) {
+                console.warn(`Custom header "${key}" ignored: reserved by the Coolify client`);
+            }
+            else {
+                filtered[key] = value;
+            }
+        }
+        this.customHeaders = filtered;
     }
     // ===========================================================================
     // Private HTTP methods
@@ -165,6 +186,7 @@ export class CoolifyClient {
                 headers: {
                     'Content-Type': 'application/json',
                     Authorization: `Bearer ${this.accessToken}`,
+                    ...this.customHeaders,
                     ...options.headers,
                 },
             });
@@ -187,7 +209,7 @@ export class CoolifyClient {
         }
         catch (error) {
             if (error instanceof TypeError && error.message.includes('fetch')) {
-                throw new Error(`Failed to connect to Coolify server at ${this.baseUrl}. Please check if the server is running and accessible.`);
+                throw new Error(`Failed to connect to Coolify server at ${this.baseUrl}. Please check if the server is running and accessible.`, { cause: error });
             }
             throw error;
         }
@@ -214,6 +236,7 @@ export class CoolifyClient {
         const response = await fetch(url, {
             headers: {
                 Authorization: `Bearer ${this.accessToken}`,
+                ...this.customHeaders,
             },
         });
         if (!response.ok) {
@@ -231,7 +254,7 @@ export class CoolifyClient {
             await this.getVersion();
         }
         catch (error) {
-            throw new Error(`Failed to connect to Coolify server: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to connect to Coolify server: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
     // ===========================================================================
@@ -386,17 +409,18 @@ export class CoolifyClient {
     async createApplicationDockerfile(data) {
         return this.request('/applications/dockerfile', {
             method: 'POST',
-            body: JSON.stringify(data),
+            body: JSON.stringify(mapFqdnToDomains(data)),
         });
     }
     async createApplicationDockerImage(data) {
         return this.request('/applications/dockerimage', {
             method: 'POST',
-            body: JSON.stringify(data),
+            body: JSON.stringify(mapFqdnToDomains(data)),
         });
     }
     async createApplicationDockerCompose(data) {
-        const payload = { ...data };
+        const mapped = mapFqdnToDomains(data);
+        const payload = { ...mapped };
         if (payload.docker_compose_raw) {
             payload.docker_compose_raw = toBase64(payload.docker_compose_raw);
         }
@@ -679,8 +703,24 @@ export class CoolifyClient {
         const param = this.isLikelyUuid(tagOrUuid) ? 'uuid' : 'tag';
         return this.request(`/deploy?${param}=${encodeURIComponent(tagOrUuid)}&force=${force}`, { method: 'GET' });
     }
-    async listApplicationDeployments(appUuid) {
-        return this.request(`/deployments/applications/${appUuid}`);
+    /**
+     * List deployments for an application.
+     *
+     * Coolify returns `{ count, deployments: Deployment[] }` for this endpoint
+     * (NOT a raw array — upstream @masonator type was incorrect).
+     *
+     * By default returns a DeploymentEssential summary (no `logs` field) because
+     * each deployment's log blob can be 30–100KB, and a typical list has 20–35
+     * deployments — exceeding MCP response token limits. Pass `includeLogs: true`
+     * to get raw Deployment objects with full build logs.
+     */
+    async listApplicationDeployments(appUuid, options) {
+        const envelope = await this.request(`/deployments/applications/${appUuid}`);
+        const deployments = Array.isArray(envelope?.deployments) ? envelope.deployments : [];
+        return {
+            count: typeof envelope?.count === 'number' ? envelope.count : deployments.length,
+            deployments: options?.includeLogs ? deployments : deployments.map(toDeploymentEssential),
+        };
     }
     // ===========================================================================
     // Team endpoints
@@ -932,7 +972,10 @@ export class CoolifyClient {
         const app = extract(results[0], 'application');
         const logs = extract(results[1], 'logs');
         const envVars = extract(results[2], 'environment_variables');
-        const deployments = extract(results[3], 'deployments');
+        // listApplicationDeployments now returns { count, deployments: [...] } —
+        // flatten back to the array that the diagnostics consumer expects.
+        const deploymentsEnvelope = extract(results[3], 'deployments');
+        const deployments = deploymentsEnvelope?.deployments ?? [];
         // Determine health status and issues
         const issues = [];
         let healthStatus = 'unknown';

package/dist/lib/docs-search.js

@@ -7,11 +7,9 @@ const DOCS_BASE_URL = 'https://coolify.io';
  * The LLM calling this tool handles semantic understanding — we just need good ranking.
  */
 export class DocsSearchEngine {
-    constructor() {
-        this.index = null;
-        this.chunks = [];
-        this.loading = null;
-    }
+    index = null;
+    chunks = [];
+    loading = null;
     async ensureLoaded() {
         if (this.index)
             return;
@@ -23,7 +21,7 @@ export class DocsSearchEngine {
     async loadAndIndex() {
         try {
             const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 15000);
+            const timeout = setTimeout(() => controller.abort(), 15_000);
             let response;
             try {
                 response = await fetch(DOCS_FULL_URL, { signal: controller.signal });

package/dist/lib/mcp-server.js

@@ -153,9 +153,10 @@ function wrapWithActions(fn, getActions, getPaginationFn) {
     }));
 }
 export class CoolifyMcpServer extends McpServer {
+    client;
+    docsSearch = new DocsSearchEngine();
     constructor(config) {
         super({ name: 'coolify', version: VERSION });
-        this.docsSearch = new DocsSearchEngine();
         this.client = new CoolifyClient(config);
         this.registerTools();
     }
@@ -308,6 +309,7 @@ export class CoolifyMcpServer extends McpServer {
             server_uuid: z.string().optional(),
             github_app_uuid: z.string().optional(),
             private_key_uuid: z.string().optional(),
+            destination_uuid: z.string().optional(),
             git_repository: z.string().optional(),
             git_branch: z.string().optional(),
             environment_name: z.string().optional(),
@@ -321,6 +323,10 @@ export class CoolifyMcpServer extends McpServer {
             name: z.string().optional(),
             description: z.string().optional(),
             fqdn: z.string().optional(),
+            domains: z.string().optional(),
+            custom_docker_run_options: z.string().optional(),
+            custom_labels: z.string().optional(),
+            instant_deploy: z.boolean().optional(),
             // Health check fields
             health_check_enabled: z.boolean().optional(),
             health_check_path: z.string().optional(),
@@ -358,6 +364,7 @@ export class CoolifyMcpServer extends McpServer {
                     return wrap(() => this.client.createApplicationPublic({
                         project_uuid: args.project_uuid,
                         server_uuid: args.server_uuid,
+                        destination_uuid: args.destination_uuid,
                         git_repository: args.git_repository,
                         git_branch: args.git_branch,
                         build_pack: args.build_pack,
@@ -367,6 +374,10 @@ export class CoolifyMcpServer extends McpServer {
                         name: args.name,
                         description: args.description,
                         fqdn: args.fqdn,
+                        domains: args.domains,
+                        custom_docker_run_options: args.custom_docker_run_options,
+                        custom_labels: args.custom_labels,
+                        instant_deploy: args.instant_deploy,
                     }));
                 case 'create_github':
                     if (!args.project_uuid ||
@@ -387,6 +398,7 @@ export class CoolifyMcpServer extends McpServer {
                         project_uuid: args.project_uuid,
                         server_uuid: args.server_uuid,
                         github_app_uuid: args.github_app_uuid,
+                        destination_uuid: args.destination_uuid,
                         git_repository: args.git_repository,
                         git_branch: args.git_branch,
                         build_pack: args.build_pack,
@@ -396,6 +408,10 @@ export class CoolifyMcpServer extends McpServer {
                         name: args.name,
                         description: args.description,
                         fqdn: args.fqdn,
+                        domains: args.domains,
+                        custom_docker_run_options: args.custom_docker_run_options,
+                        custom_labels: args.custom_labels,
+                        instant_deploy: args.instant_deploy,
                     }));
                 case 'create_key':
                     if (!args.project_uuid ||
@@ -416,6 +432,7 @@ export class CoolifyMcpServer extends McpServer {
                         project_uuid: args.project_uuid,
                         server_uuid: args.server_uuid,
                         private_key_uuid: args.private_key_uuid,
+                        destination_uuid: args.destination_uuid,
                         git_repository: args.git_repository,
                         git_branch: args.git_branch,
                         build_pack: args.build_pack,
@@ -425,6 +442,10 @@ export class CoolifyMcpServer extends McpServer {
                         name: args.name,
                         description: args.description,
                         fqdn: args.fqdn,
+                        domains: args.domains,
+                        custom_docker_run_options: args.custom_docker_run_options,
+                        custom_labels: args.custom_labels,
+                        instant_deploy: args.instant_deploy,
                     }));
                 case 'create_dockerimage':
                     if (!args.project_uuid ||
@@ -443,6 +464,7 @@ export class CoolifyMcpServer extends McpServer {
                     return wrap(() => this.client.createApplicationDockerImage({
                         project_uuid: args.project_uuid,
                         server_uuid: args.server_uuid,
+                        destination_uuid: args.destination_uuid,
                         docker_registry_image_name: args.docker_registry_image_name,
                         ports_exposes: args.ports_exposes,
                         docker_registry_image_tag: args.docker_registry_image_tag,
@@ -451,6 +473,10 @@ export class CoolifyMcpServer extends McpServer {
                         name: args.name,
                         description: args.description,
                         fqdn: args.fqdn,
+                        domains: args.domains,
+                        custom_docker_run_options: args.custom_docker_run_options,
+                        custom_labels: args.custom_labels,
+                        instant_deploy: args.instant_deploy,
                     }));
                 case 'update': {
                     if (!uuid)
@@ -709,13 +735,14 @@ export class CoolifyMcpServer extends McpServer {
         // =========================================================================
         this.tool('list_deployments', 'List deployments (summary)', { page: z.number().optional(), per_page: z.number().optional() }, async ({ page, per_page }) => wrapWithActions(() => this.client.listDeployments({ page, per_page, summary: true }), undefined, (result) => getPagination('list_deployments', page, per_page, result.length)));
         this.tool('deploy', 'Deploy by tag/UUID', { tag_or_uuid: z.string(), force: z.boolean().optional() }, async ({ tag_or_uuid, force }) => wrapWithActions(() => this.client.deployByTagOrUuid(tag_or_uuid, force), () => [{ tool: 'list_deployments', args: {}, hint: 'Check deployment status' }]));
-        this.tool('deployment', 'Manage deployment: get/cancel/list_for_app (logs excluded by default, use lines param to include)', {
+        this.tool('deployment', 'Manage deployment: get/cancel/list_for_app. Logs excluded by default on all actions — for get use `lines` (paginated tail), for list_for_app use `include_logs: true` to include raw build-log blobs.', {
             action: z.enum(['get', 'cancel', 'list_for_app']),
             uuid: z.string(),
             lines: z.number().optional(), // Include logs truncated to last N entries (omit for no logs)
             page: z.number().optional(), // Log page (1=most recent, 2=older, etc.)
             max_chars: z.number().optional(), // Limit log output to last N chars (default: 50000)
-        }, async ({ action, uuid, lines, page, max_chars }) => {
+            include_logs: z.boolean().optional(), // list_for_app only: include raw build logs (default false; upstream returns ~30KB per deployment)
+        }, async ({ action, uuid, lines, page, max_chars, include_logs }) => {
             switch (action) {
                 case 'get':
                     // If lines param specified, include logs and truncate
@@ -760,7 +787,7 @@ export class CoolifyMcpServer extends McpServer {
                 case 'cancel':
                     return wrap(() => this.client.cancelDeployment(uuid));
                 case 'list_for_app':
-                    return wrap(() => this.client.listApplicationDeployments(uuid));
+                    return wrap(() => this.client.listApplicationDeployments(uuid, { includeLogs: include_logs }));
             }
         });
         // =========================================================================

package/dist/lib/parse-headers.d.ts

@@ -0,0 +1 @@
+export declare function parseHeaders(argv: string[]): Record<string, string>;

package/dist/lib/parse-headers.js

@@ -0,0 +1,14 @@
+export function parseHeaders(argv) {
+    const headers = {};
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === '--header' && i + 1 < argv.length) {
+            const value = argv[i + 1];
+            const colonIndex = value.indexOf(':');
+            if (colonIndex > 0) {
+                headers[value.slice(0, colonIndex).trim()] = value.slice(colonIndex + 1).trim();
+            }
+            i++;
+        }
+    }
+    return headers;
+}

package/dist/types/coolify.d.ts

@@ -5,6 +5,7 @@
 export interface CoolifyConfig {
     baseUrl: string;
     accessToken: string;
+    customHeaders?: Record<string, string>;
 }
 export interface ErrorResponse {
     error?: string;
@@ -211,6 +212,7 @@ export interface CreateApplicationPublicRequest {
     name?: string;
     description?: string;
     fqdn?: string;
+    domains?: string;
     git_repository: string;
     git_branch: string;
     git_commit_sha?: string;
@@ -222,6 +224,8 @@ export interface CreateApplicationPublicRequest {
     install_command?: string;
     build_command?: string;
     start_command?: string;
+    custom_docker_run_options?: string;
+    custom_labels?: string;
     instant_deploy?: boolean;
 }
 export interface CreateApplicationPrivateGHRequest extends Omit<CreateApplicationPublicRequest, 'build_pack' | 'ports_exposes'> {
@@ -243,11 +247,14 @@ export interface CreateApplicationDockerfileRequest {
     name?: string;
     description?: string;
     fqdn?: string;
+    domains?: string;
     dockerfile: string;
     dockerfile_location?: string;
     ports_exposes?: string;
     ports_mappings?: string;
     base_directory?: string;
+    custom_docker_run_options?: string;
+    custom_labels?: string;
     instant_deploy?: boolean;
 }
 export interface CreateApplicationDockerImageRequest {
@@ -259,10 +266,13 @@ export interface CreateApplicationDockerImageRequest {
     name?: string;
     description?: string;
     fqdn?: string;
+    domains?: string;
     docker_registry_image_name: string;
     docker_registry_image_tag?: string;
     ports_exposes: string;
     ports_mappings?: string;
+    custom_docker_run_options?: string;
+    custom_labels?: string;
     instant_deploy?: boolean;
 }
 export interface CreateApplicationDockerComposeRequest {
@@ -273,16 +283,23 @@ export interface CreateApplicationDockerComposeRequest {
     destination_uuid?: string;
     name?: string;
     description?: string;
+    fqdn?: string;
+    domains?: string;
     docker_compose_raw: string;
     docker_compose_location?: string;
     docker_compose_custom_start_command?: string;
     docker_compose_custom_build_command?: string;
+    custom_docker_run_options?: string;
+    custom_labels?: string;
     instant_deploy?: boolean;
 }
 export interface UpdateApplicationRequest {
     name?: string;
     description?: string;
     fqdn?: string;
+    domains?: string;
+    custom_docker_run_options?: string;
+    custom_labels?: string;
     git_repository?: string;
     git_branch?: string;
     git_commit_sha?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masonator/coolify-mcp",
   "scope": "@masonator",
-  "version": "2.7.3",
+  "version": "2.8.1",
   "mcpName": "io.github.StuMason/coolify",
   "description": "MCP server for Coolify — 38 optimized tools for infrastructure management, diagnostics, and documentation search",
   "type": "module",
@@ -64,8 +64,8 @@
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.3",
-    "@types/jest": "^29.5.14",
+    "@eslint/js": "^10.0.1",
+    "@types/jest": "^30.0.0",
     "@types/node": "^25.0.3",
     "@typescript-eslint/eslint-plugin": "^8.51.0",
     "@typescript-eslint/parser": "^8.51.0",
@@ -74,10 +74,10 @@
     "eslint-config-prettier": "^10.1.8",
     "globals": "^17.0.0",
     "husky": "^9.0.11",
-    "jest": "^29.7.0",
+    "jest": "^30.3.0",
     "jest-junit": "^16.0.0",
     "lint-staged": "^16.2.7",
-    "markdownlint-cli2": "^0.21.0",
+    "markdownlint-cli2": "^0.22.0",
     "prettier": "^3.5.3",
     "shx": "^0.4.0",
     "ts-jest": "^29.2.6",
@@ -85,7 +85,10 @@
     "typescript-eslint": "^8.51.0"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
+  },
+  "overrides": {
+    "handlebars": "^4.7.9"
   },
   "lint-staged": {
     "*.{ts,js,json,md,yaml,yml}": "prettier --write",