@masonator/coolify-mcp 2.12.0 → 2.13.0

package/dist/lib/coolify-client.js

@@ -46,6 +46,24 @@ function mapFqdnToDomains(data) {
     }
     return { ...rest, domains: fqdn };
 }
+/**
+ * Map a failed response's status/path to an actionable hint for known Coolify quirks.
+ * Coolify sometimes returns bodyless errors (e.g. bare `HTTP 500: Internal Server Error`)
+ * that leave the caller guessing at the cause — this appends a short, testable hint for
+ * the cases we've hit in practice. Returns undefined when no known case matches.
+ */
+export function errorHint(status, path) {
+    if (status === 500 && /\/scheduled-tasks(\/|$)/.test(path)) {
+        return 'Known cause: Coolify stores scheduled-task `command` in a varchar(255) column and rejects longer commands with a bodyless 500 — check the command length (limit 255 chars).';
+    }
+    if (status === 401 || status === 403) {
+        return 'Check that COOLIFY_ACCESS_TOKEN is valid and has the required scopes for this operation.';
+    }
+    if (status === 404 && /\/[\w-]{8,}(\/|$)/.test(path)) {
+        return 'The uuid may belong to a different resource type than requested (e.g. an application uuid used on a service/database route).';
+    }
+    return undefined;
+}
 // =============================================================================
 // Summary Transformers - reduce full objects to essential fields
 // =============================================================================
@@ -305,6 +323,10 @@ export class CoolifyClient {
                         .join('; ');
                     errorMessage = `${errorMessage} - ${validationDetails}`;
                 }
+                const hint = errorHint(response.status, path);
+                if (hint) {
+                    errorMessage = `${errorMessage} (${hint})`;
+                }
                 throw new Error(errorMessage);
             }
             return data;
@@ -520,6 +542,12 @@ export class CoolifyClient {
             body: JSON.stringify(mapFqdnToDomains(data)),
         });
     }
+    /**
+     * @deprecated Coolify removed POST /applications/dockercompose upstream in
+     * v4.1.0 (coollabsio/coolify commit 6ee75cfa) in favour of POST /services.
+     * This 404s against current Coolify releases; use createService instead.
+     * Not exposed via any MCP tool — see #235.
+     */
     async createApplicationDockerCompose(data) {
         const mapped = mapFqdnToDomains(data);
         const payload = { ...mapped };
@@ -767,8 +795,9 @@ export class CoolifyClient {
             method: 'GET',
         });
     }
-    async restartService(uuid) {
-        return this.request(`/services/${uuid}/restart`, {
+    async restartService(uuid, pullLatest = false) {
+        const qs = pullLatest ? '?latest=true' : '';
+        return this.request(`/services/${uuid}/restart${qs}`, {
             method: 'GET',
         });
     }
@@ -818,7 +847,13 @@ export class CoolifyClient {
     }
     async getDeployment(uuid, options) {
         const deployment = await this.request(`/deployments/${uuid}`);
-        return options?.includeLogs ? deployment : toDeploymentEssential(deployment);
+        const essential = toDeploymentEssential(deployment);
+        // Attach the raw log string (never the raw upstream object, which also embeds
+        // the full application/server graph and secrets) onto the essential projection.
+        if (options?.includeLogs && deployment.logs) {
+            essential.logs = deployment.logs;
+        }
+        return essential;
     }
     async deployByTagOrUuid(tagOrUuid, force = false) {
         // Detect if the value looks like a UUID or a tag name
@@ -834,14 +869,22 @@ export class CoolifyClient {
      * 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.
+     * to also attach the raw log string to each essential projection (never the
+     * raw upstream deployment object, which also embeds the full application/server
+     * graph and secrets).
      */
     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),
+            deployments: deployments.map((dep) => {
+                const essential = toDeploymentEssential(dep);
+                if (options?.includeLogs && dep.logs) {
+                    essential.logs = dep.logs;
+                }
+                return essential;
+            }),
         };
     }
     // ===========================================================================
@@ -1372,6 +1415,18 @@ export class CoolifyClient {
                     healthStatus = 'unhealthy';
             }
         }
+        // Cross-check: the container can be running:healthy while the latest
+        // deployment failed/was cancelled — old code still serving, new code
+        // never arrived (#239). Skip silently if we have no app or no deployments.
+        if (app && deployments && deployments.length > 0) {
+            const latestDeployment = deployments[0];
+            const appIsRunning = (app.status || '').includes('running');
+            if (appIsRunning &&
+                (latestDeployment.status === 'failed' || latestDeployment.status === 'cancelled')) {
+                issues.push(`Running container predates the last (${latestDeployment.status}) deployment (${latestDeployment.uuid}) — the app is serving stale code. Use the deployment tool (action: get, uuid: ${latestDeployment.uuid}, lines) to see why it ${latestDeployment.status}.`);
+                healthStatus = 'unhealthy';
+            }
+        }
         return {
             application: app
                 ? {

package/dist/lib/mcp-server.d.ts

@@ -30,5 +30,38 @@ export declare class CoolifyMcpServer extends McpServer {
     private readonly docsSearch;
     constructor(config: CoolifyConfig);
     connect(transport: Transport): Promise<void>;
+    /**
+     * Poll a single deployment until it reaches a terminal status or the
+     * timeout elapses. Uses `getDeployment`'s no-logs projection
+     * (`DeploymentEssential`) while polling, and only fetches logs (once,
+     * truncated) if the deployment failed.
+     */
+    private pollDeployment;
+    /**
+     * Trigger a deploy and wait for it to finish. A tag can resolve to
+     * multiple applications, so `deployByTagOrUuid` may return several
+     * `deployment_uuid`s — only the first is polled; any others are
+     * surfaced under `additional_deployment_uuids` for the caller to check
+     * separately via `deployment get`.
+     */
+    private triggerAndWaitForDeploy;
     private registerTools;
+    /**
+     * Injectable delay for the run_once poll loop. A real setTimeout in production;
+     * tests replace it with `jest.spyOn(server, 'sleep').mockResolvedValue(undefined)`
+     * so polling logic runs without waiting on the wall clock.
+     */
+    private sleep;
+    /**
+     * Composite one-off command execution (#233 / #208): there is no upstream
+     * "run now" endpoint for scheduled tasks, so this creates a throwaway
+     * `* * * * *` task, polls list_executions until the first execution reaches a
+     * terminal status (or the poll budget runs out), and returns its status+message.
+     *
+     * The task is deleted in a finally-equivalent (try/finally-style) block so cleanup
+     * always runs — on success, on timeout, and on a polling error. If cleanup itself
+     * fails, the returned message says so loudly with the task UUID so a human can
+     * remove it manually (it would otherwise keep firing every minute).
+     */
+    private runOnceScheduledTask;
 }

package/dist/lib/mcp-server.js

@@ -152,6 +152,33 @@ function wrapWithActions(fn, getActions, getPaginationFn) {
         ],
     }));
 }
+// =============================================================================
+// Deploy wait/poll helpers (#238)
+// =============================================================================
+/** Deployment statuses that end a run — polling stops once one of these is hit. */
+const TERMINAL_DEPLOYMENT_STATUSES = new Set([
+    'finished',
+    'failed',
+    'cancelled',
+]);
+const DEFAULT_DEPLOY_TIMEOUT_SECONDS = 300;
+const DEPLOY_POLL_INTERVAL_MS = 5000;
+function isTerminalDeploymentStatus(status) {
+    return TERMINAL_DEPLOYMENT_STATUSES.has(status);
+}
+/** Isolated so tests can drive polling with jest fake timers instead of real waits. */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function durationSeconds(createdAt, updatedAt) {
+    if (!createdAt || !updatedAt)
+        return undefined;
+    const start = Date.parse(createdAt);
+    const end = Date.parse(updatedAt);
+    if (Number.isNaN(start) || Number.isNaN(end))
+        return undefined;
+    return Math.max(0, Math.round((end - start) / 1000));
+}
 export class CoolifyMcpServer extends McpServer {
     client;
     docsSearch = new DocsSearchEngine();
@@ -163,6 +190,82 @@ export class CoolifyMcpServer extends McpServer {
     async connect(transport) {
         await super.connect(transport);
     }
+    /**
+     * Poll a single deployment until it reaches a terminal status or the
+     * timeout elapses. Uses `getDeployment`'s no-logs projection
+     * (`DeploymentEssential`) while polling, and only fetches logs (once,
+     * truncated) if the deployment failed.
+     */
+    async pollDeployment(uuid, timeoutSeconds) {
+        const deadline = Date.now() + timeoutSeconds * 1000;
+        let current = (await this.client.getDeployment(uuid));
+        while (!isTerminalDeploymentStatus(current.status) && Date.now() < deadline) {
+            await sleep(DEPLOY_POLL_INTERVAL_MS);
+            current = (await this.client.getDeployment(uuid));
+        }
+        if (!isTerminalDeploymentStatus(current.status)) {
+            return {
+                status: current.status,
+                deployment_uuid: uuid,
+                application_uuid: current.application_uuid,
+                timed_out: true,
+                next_action: `Still "${current.status}" after ${timeoutSeconds}s — poll \`deployment\` (action: "get", uuid: "${uuid}") to keep watching.`,
+            };
+        }
+        if (current.status === 'failed') {
+            const withLogs = (await this.client.getDeployment(uuid, {
+                includeLogs: true,
+            }));
+            const tail = withLogs.logs ? truncateLogs(withLogs.logs, 30, 10_000) : undefined;
+            return {
+                status: current.status,
+                deployment_uuid: uuid,
+                application_uuid: current.application_uuid,
+                commit: current.commit,
+                created_at: current.created_at,
+                updated_at: current.updated_at,
+                duration_seconds: durationSeconds(current.created_at, current.updated_at),
+                logs_tail: tail?.logs,
+                logs_meta: tail
+                    ? {
+                        total_entries: tail.total,
+                        showing: `${tail.showing_start}-${tail.showing_end} of ${tail.total}`,
+                    }
+                    : undefined,
+                next_action: `Deployment failed. See logs_tail above, or \`deployment\` (action: "get", uuid: "${uuid}", lines: N) for more.`,
+            };
+        }
+        return {
+            status: current.status,
+            deployment_uuid: uuid,
+            application_uuid: current.application_uuid,
+            commit: current.commit,
+            created_at: current.created_at,
+            updated_at: current.updated_at,
+            duration_seconds: durationSeconds(current.created_at, current.updated_at),
+        };
+    }
+    /**
+     * Trigger a deploy and wait for it to finish. A tag can resolve to
+     * multiple applications, so `deployByTagOrUuid` may return several
+     * `deployment_uuid`s — only the first is polled; any others are
+     * surfaced under `additional_deployment_uuids` for the caller to check
+     * separately via `deployment get`.
+     */
+    async triggerAndWaitForDeploy(tagOrUuid, force, timeoutSeconds) {
+        const triggered = await this.client.deployByTagOrUuid(tagOrUuid, force);
+        const [first, ...rest] = triggered.deployments ?? [];
+        if (!first?.deployment_uuid) {
+            // Nothing to poll against — hand back the trigger response as-is.
+            return triggered;
+        }
+        const result = await this.pollDeployment(first.deployment_uuid, timeoutSeconds);
+        const additional = rest.map((d) => d.deployment_uuid).filter((u) => !!u);
+        if (additional.length > 0) {
+            result.additional_deployment_uuids = additional;
+        }
+        return result;
+    }
     registerTools() {
         // =========================================================================
         // Meta (2 tools)
@@ -300,6 +403,7 @@ export class CoolifyMcpServer extends McpServer {
                 'create_github',
                 'create_key',
                 'create_dockerimage',
+                'create_dockerfile',
                 'update',
                 'delete',
                 'delete_preview',
@@ -320,6 +424,8 @@ export class CoolifyMcpServer extends McpServer {
             // Docker image fields
             docker_registry_image_name: z.string().optional(),
             docker_registry_image_tag: z.string().optional(),
+            // Dockerfile fields (create_dockerfile)
+            dockerfile: z.string().optional(),
             // Update fields
             name: z.string().optional(),
             description: z.string().optional(),
@@ -565,6 +671,35 @@ export class CoolifyMcpServer extends McpServer {
                         custom_labels: args.custom_labels,
                         instant_deploy: args.instant_deploy,
                     }));
+                case 'create_dockerfile':
+                    if (!args.project_uuid || !args.server_uuid || !args.dockerfile) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: 'Error: project_uuid, server_uuid, dockerfile required',
+                                },
+                            ],
+                        };
+                    }
+                    return wrap(() => this.client.createApplicationDockerfile({
+                        project_uuid: args.project_uuid,
+                        server_uuid: args.server_uuid,
+                        destination_uuid: args.destination_uuid,
+                        dockerfile: args.dockerfile,
+                        dockerfile_location: args.dockerfile_location,
+                        ports_exposes: args.ports_exposes,
+                        base_directory: args.base_directory,
+                        environment_name: args.environment_name,
+                        environment_uuid: args.environment_uuid,
+                        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)
                         return { content: [{ type: 'text', text: 'Error: uuid required' }] };
@@ -608,6 +743,10 @@ export class CoolifyMcpServer extends McpServer {
             server_uuid: z.string().optional(),
             project_uuid: z.string().optional(),
             environment_name: z.string().optional(),
+            destination_uuid: z
+                .string()
+                .optional()
+                .describe('Destination UUID. Required if server has multiple destinations.'),
             name: z.string().optional(),
             description: z.string().optional(),
             image: z.string().optional(),
@@ -723,7 +862,11 @@ export class CoolifyMcpServer extends McpServer {
             resource: z.enum(['application', 'database', 'service']),
             action: z.enum(['start', 'stop', 'restart']),
             uuid: z.string(),
-        }, async ({ resource, action, uuid }) => {
+            pull_latest: z
+                .boolean()
+                .optional()
+                .describe('Pull latest images before restarting (services only)'),
+        }, async ({ resource, action, uuid, pull_latest }) => {
             const methods = {
                 application: {
                     start: (u) => this.client.startApplication(u),
@@ -738,7 +881,7 @@ export class CoolifyMcpServer extends McpServer {
                 service: {
                     start: (u) => this.client.startService(u),
                     stop: (u) => this.client.stopService(u),
-                    restart: (u) => this.client.restartService(u),
+                    restart: (u) => this.client.restartService(u, pull_latest),
                 },
             };
             // Generate contextual actions based on resource type and action taken
@@ -879,7 +1022,25 @@ export class CoolifyMcpServer extends McpServer {
         // Deployments (3 tools)
         // =========================================================================
         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('deploy', 'Deploy by tag/UUID', {
+            tag_or_uuid: z.string(),
+            force: z.boolean().optional(),
+            wait: z
+                .boolean()
+                .optional()
+                .describe('Wait for the deployment to reach a terminal status (finished/failed/cancelled) instead of returning immediately, polling every ~5s. If tag_or_uuid matches multiple applications (a tag can trigger several deployments), only the first is watched — the rest are returned under additional_deployment_uuids for you to check separately via `deployment get`. On failure the response includes a bounded log tail. Default false (fire-and-forget, unchanged response).'),
+            timeout_seconds: z
+                .number()
+                .optional()
+                .describe('Max seconds to poll when wait is true before giving up and returning the current status plus a next-action hint (default 300). Ignored when wait is false.'),
+        }, async ({ tag_or_uuid, force, wait, timeout_seconds }) => {
+            if (!wait) {
+                return wrapWithActions(() => this.client.deployByTagOrUuid(tag_or_uuid, force), () => [{ tool: 'list_deployments', args: {}, hint: 'Check deployment status' }]);
+            }
+            return wrapWithActions(() => this.triggerAndWaitForDeploy(tag_or_uuid, force, timeout_seconds ?? DEFAULT_DEPLOY_TIMEOUT_SECONDS), (result) => 'deployment_uuid' in result
+                ? getDeploymentActions(result.deployment_uuid, result.status, result.application_uuid)
+                : []);
+        });
         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(),
@@ -895,9 +1056,9 @@ export class CoolifyMcpServer extends McpServer {
                         const p = page ?? 1;
                         const ll = lines;
                         return wrapWithActions(async () => {
-                            const deployment = (await this.client.getDeployment(uuid, {
+                            const deployment = await this.client.getDeployment(uuid, {
                                 includeLogs: true,
-                            }));
+                            });
                             if (deployment.logs) {
                                 const result = truncateLogs(deployment.logs, ll, max_chars ?? 50000, p);
                                 deployment.logs = result.logs;
@@ -1315,17 +1476,31 @@ export class CoolifyMcpServer extends McpServer {
         // =========================================================================
         // Scheduled Tasks (1 tool - consolidated for app/service)
         // =========================================================================
-        this.tool('scheduled_tasks', 'Manage scheduled tasks for app or service: list/create/update/delete/list_executions', {
+        this.tool('scheduled_tasks', 'Manage scheduled tasks for app or service: list/create/update/delete/list_executions/run_once. ' +
+            "list_executions: the command's stdout comes back in the execution's message field. " +
+            'run_once: composite that creates a throwaway "* * * * *" task, polls list_executions every ~5s ' +
+            'for the first terminal execution (or until wait_seconds elapses, default 90), deletes the task, ' +
+            'and returns status+message. WARNING: the underlying cron may fire more than once before cleanup ' +
+            'completes — make the command idempotent (e.g. `where not exists`) or tolerate re-execution. ' +
+            'Coolify stores `command` in a varchar(255) column and rejects longer commands with a bodyless ' +
+            'HTTP 500 — keep commands to 255 chars or fewer (#234).', {
             resource: z.enum(['application', 'service']),
-            action: z.enum(['list', 'create', 'update', 'delete', 'list_executions']),
+            action: z.enum(['list', 'create', 'update', 'delete', 'list_executions', 'run_once']),
             uuid: z.string(),
             task_uuid: z.string().optional(),
             name: z.string().optional(),
-            command: z.string().optional(),
+            command: z
+                .string()
+                .max(255, 'Coolify rejects scheduled-task commands longer than 255 chars — split the command or bake a script into the container image')
+                .optional(),
             frequency: z.string().optional(),
             container: z.string().optional(),
             timeout: z.number().optional(),
             enabled: z.boolean().optional(),
+            wait_seconds: z
+                .number()
+                .optional()
+                .describe('run_once only: poll budget in seconds before giving up (default 90)'),
         }, async (args) => {
             const { resource, action, uuid, task_uuid } = args;
             const isApp = resource === 'application';
@@ -1382,6 +1557,12 @@ export class CoolifyMcpServer extends McpServer {
                     return wrap(() => isApp
                         ? this.client.listApplicationScheduledTaskExecutions(uuid, task_uuid)
                         : this.client.listServiceScheduledTaskExecutions(uuid, task_uuid));
+                case 'run_once':
+                    if (!args.command || !args.container)
+                        return {
+                            content: [{ type: 'text', text: 'Error: command, container required' }],
+                        };
+                    return this.runOnceScheduledTask(resource, uuid, args.command, args.container, args.timeout, args.wait_seconds);
             }
         });
         // =========================================================================
@@ -1516,4 +1697,131 @@ export class CoolifyMcpServer extends McpServer {
         });
         this.tool('redeploy_project', 'Redeploy all apps in project', { project_uuid: z.string(), force: z.boolean().optional() }, async ({ project_uuid, force }) => wrap(() => this.client.redeployProjectApps(project_uuid, force ?? true)));
     }
+    /**
+     * Injectable delay for the run_once poll loop. A real setTimeout in production;
+     * tests replace it with `jest.spyOn(server, 'sleep').mockResolvedValue(undefined)`
+     * so polling logic runs without waiting on the wall clock.
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Composite one-off command execution (#233 / #208): there is no upstream
+     * "run now" endpoint for scheduled tasks, so this creates a throwaway
+     * `* * * * *` task, polls list_executions until the first execution reaches a
+     * terminal status (or the poll budget runs out), and returns its status+message.
+     *
+     * The task is deleted in a finally-equivalent (try/finally-style) block so cleanup
+     * always runs — on success, on timeout, and on a polling error. If cleanup itself
+     * fails, the returned message says so loudly with the task UUID so a human can
+     * remove it manually (it would otherwise keep firing every minute).
+     */
+    async runOnceScheduledTask(resource, uuid, command, container, timeout, waitSeconds) {
+        const isApp = resource === 'application';
+        const pollIntervalMs = 5000;
+        const budgetSeconds = waitSeconds ?? 90;
+        const maxAttempts = Math.max(1, Math.ceil((budgetSeconds * 1000) / pollIntervalMs));
+        const name = `oneoff-${Math.random().toString(36).slice(2, 10)}`;
+        let taskUuid;
+        try {
+            const task = isApp
+                ? await this.client.createApplicationScheduledTask(uuid, {
+                    name,
+                    command,
+                    frequency: '* * * * *',
+                    container,
+                    timeout,
+                    enabled: true,
+                })
+                : await this.client.createServiceScheduledTask(uuid, {
+                    name,
+                    command,
+                    frequency: '* * * * *',
+                    container,
+                    timeout,
+                    enabled: true,
+                });
+            taskUuid = task.uuid;
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error creating one-off task: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+        let execution;
+        let pollErrorMessage;
+        try {
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                const executions = isApp
+                    ? await this.client.listApplicationScheduledTaskExecutions(uuid, taskUuid)
+                    : await this.client.listServiceScheduledTaskExecutions(uuid, taskUuid);
+                const first = executions[0];
+                if (first && first.status !== 'running') {
+                    execution = first;
+                    break;
+                }
+                if (attempt < maxAttempts - 1)
+                    await this.sleep(pollIntervalMs);
+            }
+        }
+        catch (error) {
+            pollErrorMessage = error instanceof Error ? error.message : String(error);
+        }
+        // Cleanup always runs, regardless of how the poll loop above ended.
+        let deleteErrorMessage;
+        try {
+            if (isApp) {
+                await this.client.deleteApplicationScheduledTask(uuid, taskUuid);
+            }
+            else {
+                await this.client.deleteServiceScheduledTask(uuid, taskUuid);
+            }
+        }
+        catch (error) {
+            deleteErrorMessage = error instanceof Error ? error.message : String(error);
+        }
+        const cleanupNote = deleteErrorMessage
+            ? `WARNING: failed to delete one-off task ${taskUuid} — it will keep firing every minute ` +
+                `until it is removed manually. Delete error: ${deleteErrorMessage}`
+            : `One-off task ${taskUuid} deleted.`;
+        if (pollErrorMessage) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error polling one-off task ${taskUuid} executions: ${pollErrorMessage}. ${cleanupNote}`,
+                    },
+                ],
+            };
+        }
+        if (!execution) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Timed out after ${budgetSeconds}s waiting for one-off task ${taskUuid} to produce ` +
+                            `an execution. ${cleanupNote}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: execution.status,
+                        message: execution.message,
+                        task_uuid: taskUuid,
+                        cleanup: cleanupNote,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
 }

package/dist/types/coolify.d.ts

@@ -726,6 +726,20 @@ export interface DeployByTagRequest {
     uuid?: string;
     force?: boolean;
 }
+/**
+ * Response from `GET /deploy?tag=|uuid=`. A tag can match multiple
+ * applications, so Coolify returns one entry per triggered deployment.
+ * `message` at the top level is kept for backwards compatibility with
+ * older/mocked callers that only ever saw a bare `{ message }`.
+ */
+export interface DeployTriggerResponse {
+    message?: string;
+    deployments?: Array<{
+        message?: string;
+        resource_uuid?: string;
+        deployment_uuid?: string;
+    }>;
+}
 export interface Team {
     id: number;
     uuid?: string;
@@ -1131,4 +1145,5 @@ export interface DeploymentEssential {
     updated_at: string;
     logs_available?: boolean;
     logs_info?: string;
+    logs?: string;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masonator/coolify-mcp",
   "scope": "@masonator",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "mcpName": "io.github.StuMason/coolify",
   "description": "MCP server for Coolify — 42 optimized tools for infrastructure management, diagnostics, and documentation search",
   "type": "module",
@@ -28,6 +28,7 @@
     "test:integration": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=integration --testTimeout=60000",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
+    "check:spec-drift": "node scripts/check-client-spec-drift.mjs",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "prepare": "husky",
@@ -66,7 +67,7 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/jest": "^30.0.0",
-    "@types/node": "^25.0.3",
+    "@types/node": "^26.0.0",
     "@typescript-eslint/eslint-plugin": "^8.51.0",
     "@typescript-eslint/parser": "^8.51.0",
     "dotenv": "^17.2.3",
@@ -88,7 +89,22 @@
     "node": ">=20"
   },
   "overrides": {
-    "handlebars": "^4.7.9"
+    "handlebars": "^4.7.9",
+    "qs": "^6.15.2",
+    "hono": "^4.12.25",
+    "@hono/node-server": "^2.0.5",
+    "express-rate-limit": "^8.5.2",
+    "path-to-regexp": "^8.4.2",
+    "@modelcontextprotocol/sdk": {
+      "ajv": "^8.20.0"
+    },
+    "fast-uri": "^4.0.0",
+    "ip-address": "^10.2.0",
+    "flatted": "^3.4.2",
+    "brace-expansion": "^5.0.6",
+    "picomatch": "^4.0.4",
+    "js-yaml": "^4.2.0",
+    "markdown-it": "^14.2.0"
   },
   "lint-staged": {
     "*.{ts,js,json,md,yaml,yml}": "prettier --write",