@jurislm/coolify-plugin 4.0.20 → 4.0.22

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "coolify-plugin",
-  "version": "4.0.20",
+  "version": "4.0.22",
   "description": "Fallback Codex metadata for local stdio Coolify tools.",
   "author": {
     "name": "JurisLM",

package/README.md

@@ -1,6 +1,6 @@
 # @jurislm/coolify-plugin
 
-Portable Coolify MCP plugin. It exposes focused `coolify_*` stdio tools generated from one pinned Coolify API contract.
+Portable Coolify MCP plugin. It exposes focused `coolify_*` tools generated from one pinned Coolify API contract, plus explicit composite tools for common workflows.
 
 ## Scope
 
@@ -33,6 +33,10 @@ codex plugin marketplace add https://github.com/jurislm/coolify-plugin
 codex plugin add coolify-plugin@coolify-marketplace
 ```
 
+To check a connection, call `coolify_get_mcp_version`, then `coolify_check_connection`. The second tool reports the selected variable pair, whether a URL and credential are present, and the HTTP status of `/health` and `/version`. It never returns credential values. With a URL but no credential, it still checks public `/health` and leaves `/version` unattempted. A healthy `/health` with a 401 from `/version` means the instance is reachable but rejected the authenticated request; the response alone does not establish whether the credential expired, was revoked, or came from the wrong launcher.
+
+Check the active MCP registration separately. A standalone server named `coolify` can run the same package while the marketplace plugin's MCP is disabled. `coolify_get_mcp_version` identifies the package version, not which registration launched it. `coolify_get_infrastructure_overview` reports authentication failures and all-list failures as tool errors. When only some lists fail for other reasons, their counts are `null` and `complete` is `false`.
+
 ## Install in Cursor
 
 In Cursor, open **Customize → Plugins → Add Marketplace → Import from GitHub**, enter `https://github.com/jurislm/coolify-plugin`, then install **Coolify Plugin**. The marketplace selects `plugins/cursor`, keeping the Codex-only root `.mcp.json` out of Cursor's plugin root. For Cloud Agents, set both `COOLIFY_BASE_URL` and `COOLIFY_ACCESS_TOKEN` in the Cloud environment's secrets and start a new agent from that environment. Local agents can use the plugin's **Configure** panel. After updating from v4.0.16 or earlier, re-enter both Local Configure fields because their variable names changed. If either Cloud environment variable is set, the plugin uses only the Cloud pair and does not mix it with Configure values. Run a read-only Coolify tool to verify provider access.
@@ -43,7 +47,7 @@ For local agents, a complete saved Configure URL/token pair takes precedence ove
 
 ## OpenAPI contract
 
-`openapi/coolify-openapi.json` is built from the official Coolify v4.3.23 release. `api/manifest.json` records the upstream SHA-256, the current API contract corrections, and the persisted SHA-256. `bun run api:check` verifies the contract offline before checking generated parity. The runtime uses the generated schemas directly.
+`openapi/coolify-openapi.json` is built from the official Coolify v4.3.23 release. `api/manifest.json` records the upstream SHA-256, the current API contract corrections, and the persisted SHA-256. `bun run api:check` verifies the contract offline before checking generated parity. The server registers every generated operation with its generated schema and adds explicit composite capabilities for connection checks, inventory, diagnostics, and batch operations.
 
 ```sh
 bun run api:fetch

package/dist/capabilities.d.ts

@@ -1,3 +1,4 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { CoolifyClient } from "./client.js";
-export declare function registerCapabilities(server: McpServer, client: CoolifyClient): void;
+import type { CoolifyConfig } from "./config.js";
+export declare function registerCapabilities(server: McpServer, client: CoolifyClient, config: CoolifyConfig): void;

package/dist/capabilities.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { redactSensitive } from "./client.js";
+import { CoolifyApiError, redactSensitive } from "./client.js";
 import { operations } from "./generated/operations.js";
 import { pluginVersion } from "./version.js";
 const outputSchema = z.object({ data: z.unknown(), status: z.number(), request: z.object({ method: z.string(), path: z.string() }) });
@@ -27,7 +27,7 @@ function truncateLogs(logs, lineLimit = 200, charLimit = 50_000) {
 function environmentSummary(value) {
     return rows(value).map((item) => ({ key: item.key, is_build_time: item.is_buildtime === true }));
 }
-export function registerCapabilities(server, client) {
+export function registerCapabilities(server, client, config) {
     const call = async (name, input = {}) => {
         const operation = operations.find((item) => item.name === name);
         if (!operation)
@@ -44,23 +44,31 @@ export function registerCapabilities(server, client) {
     };
     const settledRows = async (names) => {
         const settled = await Promise.allSettled(names.map((name) => call(`coolify_list_${name}`)));
+        const auth = settled.find((entry) => entry.status === "rejected" && entry.reason instanceof CoolifyApiError && [401, 403].includes(entry.reason.status));
+        if (auth?.status === "rejected")
+            throw auth.reason;
+        const first = settled[0];
+        if (first?.status === "rejected" && settled.every((entry) => entry.status === "rejected"))
+            throw first.reason;
         const values = [];
         const errors = [];
+        const failed = new Set();
         settled.forEach((entry, index) => {
             if (entry.status === "fulfilled")
                 values[index] = rows(entry.value);
             else {
                 values[index] = [];
+                failed.add(index);
                 errors.push(`${names[index]}: ${errorMessage(entry.reason)}`);
             }
         });
-        return { values, errors };
+        return { values, errors, failed };
     };
     const overview = async () => {
         const names = ["servers", "projects", "applications", "databases", "services"];
-        const { values, errors } = await settledRows(names);
+        const { values, errors, failed } = await settledRows(names);
         const data = Object.fromEntries(names.map((name, index) => [name, values[index]]));
-        return { summary: Object.fromEntries(names.map((name, index) => [name, values[index].length])), ...data, ...(errors.length ? { errors } : {}) };
+        return { complete: errors.length === 0, summary: Object.fromEntries(names.map((name, index) => [name, failed.has(index) ? null : values[index].length])), ...data, ...(errors.length ? { errors } : {}) };
     };
     const batch = async (resources, action) => {
         const settled = await Promise.allSettled(resources.map(action));
@@ -93,6 +101,21 @@ export function registerCapabilities(server, client) {
         return rows(apps).filter((app) => environmentIds.has(app.environment_id));
     };
     register("coolify_get_mcp_version", "Get the local Coolify plugin version.", z.object({}), { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async () => ({ name: "@jurislm/coolify-plugin", version: pluginVersion }));
+    register("coolify_check_connection", "Check selected configuration and Coolify API status without exposing credentials.", z.object({}), { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async () => {
+        const probe = async (name) => {
+            const operation = operations.find((item) => item.name === name);
+            if (!operation || !config.baseUrl || (!config.token && operation.path !== "/health"))
+                return null;
+            try {
+                return (await client.request(operation, {})).status;
+            }
+            catch (error) {
+                return error instanceof CoolifyApiError && error.status > 0 ? error.status : null;
+            }
+        };
+        const [healthStatus, versionStatus] = await Promise.all([probe("coolify_healthcheck"), probe("coolify_version")]);
+        return { plugin_version: pluginVersion, configuration: { selected_variables: config.selectedVariables ?? "unknown", base_url_configured: Boolean(config.baseUrl), credential_present: Boolean(config.token) }, provider: { health_status: healthStatus, version_status: versionStatus } };
+    });
     register("coolify_get_infrastructure_overview", "Summarize Coolify infrastructure.", z.object({}), { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, overview);
     register("coolify_diagnose_application", "Diagnose an application by UUID, name, or domain.", z.object({ query: z.string() }), { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async ({ query }) => {
         let app;

package/dist/client.js

@@ -42,7 +42,7 @@ export class CoolifyClient {
         if (!baseUrl)
             throw new CoolifyApiError(0, operation.method, operation.path, "COOLIFY_BASE_URL is required");
         const token = this.config.token;
-        if (!token)
+        if (!token && !(operation.method === "GET" && operation.path === "/health"))
             throw new CoolifyApiError(0, operation.method, operation.path, "COOLIFY_ACCESS_TOKEN is required");
         let path = operation.path;
         for (const parameter of operation.parameters)
@@ -55,7 +55,9 @@ export class CoolifyClient {
         for (const parameter of operation.parameters)
             if (parameter.location === "query")
                 appendQuery(url, parameter.name, input[parameter.name]);
-        const headers = new Headers({ accept: "application/json, text/plain, */*", authorization: `Bearer ${token}` });
+        const headers = new Headers({ accept: "application/json, text/plain, */*" });
+        if (token)
+            headers.set("authorization", `Bearer ${token}`);
         const init = { method: operation.method, headers, signal: AbortSignal.timeout(this.config.timeoutMs) };
         if (input.body !== undefined && !["GET", "HEAD"].includes(operation.method)) {
             headers.set("content-type", "application/json");
@@ -69,7 +71,8 @@ export class CoolifyClient {
             response = await this.fetchImpl(url, init);
         }
         catch (error) {
-            throw new CoolifyApiError(0, operation.method, path, `Coolify request failed for ${operation.method} ${path}: ${error instanceof Error ? error.message.replaceAll(token, "[REDACTED]") : "request error"}`);
+            const cause = error instanceof Error ? error.message : "request error";
+            throw new CoolifyApiError(0, operation.method, path, `Coolify request failed for ${operation.method} ${path}: ${token ? cause.replaceAll(token, "[REDACTED]") : cause}`);
         }
         if (!response.ok) {
             let fields = "";
@@ -78,7 +81,7 @@ export class CoolifyClient {
                     const body = await response.json();
                     const errors = body?.errors;
                     if (errors && typeof errors === "object" && !Array.isArray(errors)) {
-                        fields = Object.keys(errors).filter((key) => /^[a-z][a-z0-9_.-]{0,63}$/iu.test(key)).slice(0, 8).map((key) => key.replaceAll(token, "[REDACTED]")).join(", ");
+                        fields = Object.keys(errors).filter((key) => /^[a-z][a-z0-9_.-]{0,63}$/iu.test(key)).slice(0, 8).map((key) => token ? key.replaceAll(token, "[REDACTED]") : key).join(", ");
                     }
                 }
                 catch { }

package/dist/config.d.ts

@@ -1,6 +1,7 @@
 export interface CoolifyConfig {
     baseUrl?: string;
     token?: string;
+    selectedVariables?: "COOLIFY_CLOUD_*" | "CURSOR_COOLIFY_*" | "COOLIFY_*" | "none";
     timeoutMs: number;
 }
 export declare class ConfigError extends Error {

package/dist/config.js

@@ -21,8 +21,9 @@ export function loadConfig(env = process.env) {
     const useConfigure = configureComplete || (!canonicalComplete && Boolean(configureUrl || configureToken));
     const rawUrl = useCloud ? cloudUrl : useConfigure ? configureUrl : canonicalUrl;
     const token = useCloud ? cloudToken : useConfigure ? configureToken : canonicalToken;
+    const selectedVariables = useCloud ? "COOLIFY_CLOUD_*" : useConfigure ? "CURSOR_COOLIFY_*" : canonicalUrl || canonicalToken ? "COOLIFY_*" : "none";
     if (!rawUrl)
-        return { ...(token ? { token } : {}), timeoutMs: 30_000 };
+        return { ...(token ? { token } : {}), selectedVariables, timeoutMs: 30_000 };
     let url;
     try {
         url = new URL(rawUrl);
@@ -38,5 +39,5 @@ export function loadConfig(env = process.env) {
     url.pathname = url.pathname.replace(/\/+$/u, "");
     if (!url.pathname.endsWith("/api/v1"))
         url.pathname = `${url.pathname}/api/v1`.replace(/^\/\//u, "/");
-    return { baseUrl: url.toString().replace(/\/$/u, ""), ...(token ? { token } : {}), timeoutMs: 30_000 };
+    return { baseUrl: url.toString().replace(/\/$/u, ""), ...(token ? { token } : {}), selectedVariables, timeoutMs: 30_000 };
 }

package/dist/server.js

@@ -30,6 +30,6 @@ export function createServer(config, fetchImpl) {
             }
         });
     }
-    registerCapabilities(server, client);
+    registerCapabilities(server, client, config);
     return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jurislm/coolify-plugin",
-  "version": "4.0.20",
+  "version": "4.0.22",
   "description": "Portable local stdio MCP plugin for Coolify",
   "publishConfig": {
     "access": "public"

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "coolify-plugin",
-  "version": "4.0.20",
+  "version": "4.0.22",
   "description": "Portable Coolify MCP plugin with local stdio tools generated from the official OpenAPI contract.",
   "author": {
     "name": "JurisLM",