@jurislm/coolify-plugin 4.0.28 → 4.1.0

package/.codex-plugin/plugin.json

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

package/dist/client.d.ts

@@ -16,7 +16,8 @@ export interface BinaryEnvelope {
 }
 export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 type Operation = Pick<GeneratedOperation, "method" | "path" | "parameters">;
-export declare function redactSensitive<T>(value: T): T;
+export declare function isEnvOperation(path: string): boolean;
+export declare function redactSensitive<T>(value: T, tokens?: Array<string | undefined>, envResponse?: boolean): T;
 export declare class CoolifyClient {
     private readonly config;
     private readonly fetchImpl;

package/dist/client.js

@@ -1,8 +1,10 @@
 import { isAlias, isScalar, parseDocument, stringify, visit } from "yaml";
 import { CoolifyApiError, redactErrorText } from "./errors.js";
 const sensitiveKey = /(^value$|real_?value|private_?key|api_?key|user_?key|webhook_?url|token|secret|password|authorization|cookie)/iu;
+const envValueKey = /^(value|real_value)$/u;
+const envPath = /\/envs(\/|$)/u;
 const composeKey = /^(docker_compose(_pr)?(_raw)?|configuration)$/u;
-const composeSecretName = /(password|passwd|secret|token|private|credential|api_?key|access_?key|authorization|cookie)/iu;
+const composeSecretName = /(password|passwd|secret|token|private|credential|api_?key|access_?key|root_?user|authorization|cookie)/iu;
 const composeSecretSegment = /(^|[_.-])(key|pass|pwd|auth)($|[_.-])/iu;
 const interpolation = /^\$\{?[A-Za-z_][A-Za-z0-9_]*\}?$/u;
 const urlCredential = /([a-z][a-z0-9+.-]{0,31}:\/\/[^\s:/@]{0,256}):([^\s/?#]{1,256})@/giu;
@@ -26,12 +28,65 @@ function redactUrlCredentials(text) {
 function isQuerySecret(name) {
     return querySecretName.test(name) || name.toLowerCase().split(/[_.-]/u).some((segment) => querySecretSegments.has(segment));
 }
+const commandKey = /^(command|entrypoint|test)$/u;
+const secretFlagName = /(requirepass|masterauth)/iu;
+const portValue = /^[\d.:[\]]+(\/(tcp|udp|sctp))?$/iu;
+const envOption = /(^|\s)(-e|--env)(=|\s+)(?:"([A-Za-z_][\w.]{0,127})=([^"\n]{0,4096})"|'([A-Za-z_][\w.]{0,127})=([^'\n]{0,4096})'|([A-Za-z_][\w.]{0,127})=("[^"\n]{0,4096}"|'[^'\n]{0,4096}'|[^\s"']*))/gu;
+const flagEquals = /(^|\s)(--?[A-Za-z][\w-]{0,63})=("[^"\n]{0,4096}"|'[^'\n]{0,4096}'|[^\s"']+)/gu;
+const flagSpace = /(^|\s)(--?[A-Za-z][\w-]{0,63})(\s+)("[^"\n]{0,4096}"|'[^'\n]{0,4096}'|[^\s"'-][^\s"']*)/gu;
+function unquote(value) {
+    return value.replace(/^(["'])([\s\S]*)\1$/u, "$2");
+}
+function quoteOf(value) {
+    return value.startsWith("\"") || value.startsWith("'") ? value[0] : "";
+}
+function isSecretFlag(flag) {
+    if (flag === "-p")
+        return true;
+    if (!flag.startsWith("--"))
+        return false;
+    const name = flag.slice(2).replace(/-/gu, "_");
+    return composeSecretName.test(name) || composeSecretSegment.test(name) || secretFlagName.test(name);
+}
+function isSecretFlagValue(flag, value) {
+    const bare = unquote(value);
+    if (bare === "" || bare === "[REDACTED]" || interpolation.test(bare) || flagValue.test(bare))
+        return false;
+    return flag !== "-p" || !portValue.test(bare);
+}
+function redactCommandLine(text) {
+    return text
+        .replace(envOption, (match, lead, flag, separator, doubleKey, _doubleValue, singleKey, _singleValue, key, value) => {
+        if (doubleKey !== undefined)
+            return isComposeSecret(doubleKey, _doubleValue) ? `${lead}${flag}${separator}"${doubleKey}=[REDACTED]"` : match;
+        if (singleKey !== undefined)
+            return isComposeSecret(singleKey, _singleValue) ? `${lead}${flag}${separator}'${singleKey}=[REDACTED]'` : match;
+        if (key === undefined || value === undefined)
+            return match;
+        const quote = quoteOf(value);
+        return isComposeSecret(key, unquote(value)) ? `${lead}${flag}${separator}${key}=${quote}[REDACTED]${quote}` : match;
+    })
+        .replace(flagEquals, (match, lead, flag, value) => isSecretFlag(flag) && isSecretFlagValue(flag, value) ? `${lead}${flag}=${quoteOf(value)}[REDACTED]${quoteOf(value)}` : match)
+        .replace(flagSpace, (match, lead, flag, space, value) => isSecretFlag(flag) && isSecretFlagValue(flag, value) ? `${lead}${flag}${space}${quoteOf(value)}[REDACTED]${quoteOf(value)}` : match);
+}
+function redactCommand(value) {
+    if (typeof value === "string")
+        return redactCommandLine(value);
+    if (!Array.isArray(value))
+        return value;
+    return value.map((token, index) => {
+        if (typeof token !== "string")
+            return token;
+        const flag = value[index - 1];
+        return typeof flag === "string" && !flag.includes("=") && isSecretFlag(flag) && isSecretFlagValue(flag, token) ? "[REDACTED]" : redactCommandLine(token);
+    });
+}
 const composeAliasLimit = 100;
 function redactComposeValue(value) {
     if (Array.isArray(value))
         return value.map(redactComposeValue);
     if (value && typeof value === "object") {
-        return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, isComposeSecret(key, child) ? "[REDACTED]" : redactComposeValue(child)]));
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, isComposeSecret(key, child) ? "[REDACTED]" : redactComposeValue(commandKey.test(key) ? redactCommand(child) : child)]));
     }
     if (typeof value !== "string")
         return value;
@@ -84,18 +139,34 @@ function redactComposeText(text) {
     const decoded = decodeBase64Text(text);
     return decoded === undefined ? redactComposeYaml(text) : Buffer.from(redactComposeYaml(decoded), "utf8").toString("base64");
 }
-export function redactSensitive(value) {
+function withoutTokens(text, tokens) {
+    return tokens.reduce((redacted, token) => token ? redacted.replaceAll(token, "[REDACTED]") : redacted, text);
+}
+export function isEnvOperation(path) {
+    return envPath.test(path);
+}
+export function redactSensitive(value, tokens = [], envResponse = false) {
     if (typeof value === "string")
-        return redactUrlCredentials(value);
+        return withoutTokens(redactUrlCredentials(value), tokens);
     if (Array.isArray(value))
-        return value.map(redactSensitive);
+        return value.map((item) => redactSensitive(item, tokens, envResponse));
     if (!value || typeof value !== "object")
         return value;
     const binary = value.encoding === "base64" && typeof value.contentType === "string" && typeof value.value === "string";
-    return Object.fromEntries(Object.entries(value).map(([key, child]) => [
-        key,
-        sensitiveKey.test(key) && !(binary && key === "value") ? "[REDACTED]" : composeKey.test(key) && typeof child === "string" ? redactComposeText(child) : redactSensitive(child),
-    ]));
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, redactField(key, child, tokens, envResponse, binary)]));
+}
+function redactField(key, child, tokens, envResponse, binary) {
+    if (binary && key === "value")
+        return child;
+    if (envResponse && envValueKey.test(key))
+        return typeof child === "string" ? withoutTokens(child, tokens) : child;
+    if (sensitiveKey.test(key))
+        return "[REDACTED]";
+    if (composeKey.test(key) && typeof child === "string")
+        return withoutTokens(redactComposeText(child), tokens);
+    if (key === "custom_docker_run_options" && typeof child === "string")
+        return withoutTokens(redactUrlCredentials(redactCommandLine(child)), tokens);
+    return redactSensitive(child, tokens, envResponse);
 }
 function pathValue(value, name) {
     if (value === undefined || value === null)
@@ -193,7 +264,7 @@ export class CoolifyClient {
         catch {
             throw new Error("Coolify API returned an unreadable response body");
         }
-        return redactSensitive({ data, status: response.status, request: { method: operation.method, path } });
+        return redactSensitive({ data, status: response.status, request: { method: operation.method, path } }, [token], isEnvOperation(operation.path));
     }
 }
 export { CoolifyApiError };

package/dist/server.js

@@ -1,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { CoolifyClient, redactSensitive } from "./client.js";
+import { CoolifyClient, isEnvOperation, redactSensitive } from "./client.js";
 import { formatToolError } from "./errors.js";
 import { registerCapabilities } from "./capabilities.js";
 import { operations } from "./generated/operations.js";
@@ -8,7 +8,7 @@ import { pluginVersion } from "./version.js";
 const outputRequestSchema = z.object({ method: z.string(), path: z.string() });
 export function createServer(config, fetchImpl) {
     const client = new CoolifyClient(config, fetchImpl);
-    const server = new McpServer({ name: "coolify-plugin", version: pluginVersion }, { instructions: "Use read tools to identify exact Coolify resources before mutations. Never expose tokens or secret values." });
+    const server = new McpServer({ name: "coolify-plugin", version: pluginVersion }, { instructions: "Use read tools to identify exact Coolify resources before mutations. Never expose the Coolify access token. Env tools return actual environment variable values; report them only when the user asks." });
     for (const operation of operations) {
         server.registerTool(operation.name, {
             title: operation.title,
@@ -20,7 +20,7 @@ export function createServer(config, fetchImpl) {
             try {
                 const envelope = await client.request(operation, input);
                 const data = operation.responseSchema.parse(envelope.data);
-                const structuredContent = redactSensitive({ data, status: envelope.status, request: envelope.request });
+                const structuredContent = redactSensitive({ data, status: envelope.status, request: envelope.request }, [config.token], isEnvOperation(operation.path));
                 return { structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
             }
             catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jurislm/coolify-plugin",
-  "version": "4.0.28",
+  "version": "4.1.0",
   "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.28",
+  "version": "4.1.0",
   "description": "Portable Coolify MCP plugin with local stdio tools generated from the official OpenAPI contract.",
   "author": {
     "name": "JurisLM",

package/skills/coolify/SKILL.md

@@ -5,4 +5,4 @@ description: Manage a configured Coolify instance through generated local MCP to
 
 # Coolify
 
-Use `coolify_*` tools only after resolving the target resource. Read before mutations and do not expose `COOLIFY_ACCESS_TOKEN` or returned secret values.
+Use `coolify_*` tools only after resolving the target resource. Read before mutations and do not expose `COOLIFY_ACCESS_TOKEN`. Env tools return actual environment variable values, including `is_shown_once` ones; report them only when the user asks.