@jurislm/coolify-plugin 3.7.1

package/.app.json.example

@@ -0,0 +1,4 @@
+{
+  "name": "coolify-plugin",
+  "description": "No app surface: this plugin is local stdio MCP only."
+}

package/.codex-plugin/plugin.json

@@ -0,0 +1,25 @@
+{
+  "name": "coolify-plugin",
+  "version": "3.7.1",
+  "description": "Fallback Codex metadata for local stdio Coolify tools.",
+  "author": {
+    "name": "JurisLM"
+  },
+  "license": "MIT",
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json",
+  "interface": {
+    "displayName": "Coolify",
+    "shortDescription": "Local Coolify API tools",
+    "longDescription": "Generated local stdio tools for a configured Coolify instance.",
+    "developerName": "JurisLM",
+    "category": "Developer Tools",
+    "capabilities": [
+      "MCP",
+      "Local"
+    ],
+    "defaultPrompt": [
+      "List my Coolify resources."
+    ]
+  }
+}

package/.mcp.json

@@ -0,0 +1,5 @@
+{
+  "mcpServers": {
+    "coolify": { "type": "stdio", "command": "bun", "args": ["dist/index.js"], "cwd": "./" }
+  }
+}

package/.mcp.json.example

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "coolify": {
+      "type": "stdio",
+      "command": "bun",
+      "args": ["/absolute/path/to/coolify-plugin/dist/index.js"]
+    }
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 terry90918
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# @jurislm/coolify-plugin
+
+Portable Coolify MCP plugin. It exposes focused `coolify_*` stdio tools generated from the committed official Coolify OpenAPI snapshot.
+
+## Configure
+
+Only these environment variables are accepted:
+
+```sh
+export COOLIFY_URL=https://coolify.example
+export COOLIFY_TOKEN=your-api-token
+```
+
+Build and run locally:
+
+```sh
+bun install --frozen-lockfile
+bun run check
+bun dist/index.js
+```
+
+`mcp.json` is a portable stdio registration; `.mcp.json.example` is the secret-free absolute-path example. NPM package release is allowed. Remote MCP transport, OAuth, vault, hosting, and OpenAI Plugin Directory submission are out of scope.
+
+## OpenAPI contract
+
+`openapi/coolify-openapi.json` is fetched from the official Coolify repository. `api/manifest.json` records its source, fetch time, persisted-snapshot SHA-256, document/info versions, path count, and operation count. `bun run api:check` verifies the snapshot offline before checking generated parity.
+
+```sh
+bun run api:fetch
+bun run api:generate
+bun run api:check
+```
+
+## Checks
+
+```sh
+bun run api:check
+bun run typecheck
+bun test
+bun run build
+bun run package:check
+```
+
+## License
+
+MIT

package/api/manifest.json

@@ -0,0 +1,9 @@
+{
+  "sourceUrl": "https://raw.githubusercontent.com/coollabsio/coolify/main/openapi.json",
+  "fetchedAt": "2026-09-16T10:31:42.036Z",
+  "sha256": "4dbb392aac5e0a46186c4e6e5237f86d9534bb99bf6b8b82351a513598af3900",
+  "openapiVersion": "3.1.0",
+  "infoVersion": "0.1",
+  "pathCount": 192,
+  "operationCount": 275
+}

package/dist/capabilities.d.ts

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

package/dist/capabilities.js

@@ -0,0 +1,201 @@
+import { z } from "zod";
+import { 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() }) });
+const databaseTypes = ["dragonfly", "keydb", "clickhouse"];
+const truncationPrefix = "...[truncated]...\n";
+function rows(value) {
+    if (Array.isArray(value))
+        return value.filter((item) => !!item && typeof item === "object");
+    if (!value || typeof value !== "object")
+        return [];
+    for (const key of ["data", "items", "results", "deployments", "applications", "databases", "resources", "services"]) {
+        const nested = value[key];
+        if (Array.isArray(nested))
+            return rows(nested);
+    }
+    return [];
+}
+function status(value) { return typeof value.status === "string" ? value.status : ""; }
+function unhealthy(value) { return /exited|unhealthy|error|stopped/iu.test(status(value)); }
+function errorMessage(value) { return value instanceof Error ? value.message : String(value); }
+function truncateLogs(logs, lineLimit = 200, charLimit = 50_000) {
+    if (logs.split("\n").length <= lineLimit && logs.length <= charLimit)
+        return logs;
+    let result = logs.split("\n").slice(-lineLimit).join("\n");
+    if (result.length > charLimit)
+        result = truncationPrefix + result.slice(-(charLimit - truncationPrefix.length));
+    else
+        result = truncationPrefix + result;
+    return result;
+}
+function environmentSummary(value) {
+    return rows(value).map((item) => ({ key: item.key, is_build_time: item.is_build_time ?? item.is_buildtime ?? false }));
+}
+export function registerV36Capabilities(server, client) {
+    const call = async (name, input = {}) => {
+        const operation = operations.find((item) => item.name === name);
+        if (!operation)
+            throw new Error(`Missing generated operation: ${name}`);
+        return (await client.request(operation, operation.inputSchema.parse(input))).data;
+    };
+    const result = (name, data) => {
+        const structuredContent = redactSensitive({ data, status: 200, request: { method: "COMPOSITE", path: `/capabilities/${name}` } });
+        return { structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
+    };
+    const register = (name, description, inputSchema, annotations, handler) => {
+        server.registerTool(name, { title: name, description, inputSchema, outputSchema, annotations }, async (input) => result(name, await handler(input)));
+    };
+    const settledRows = async (names) => {
+        const settled = await Promise.allSettled(names.map((name) => call(`coolify_list_${name}`)));
+        const values = [];
+        const errors = [];
+        settled.forEach((entry, index) => {
+            if (entry.status === "fulfilled")
+                values[index] = rows(entry.value);
+            else {
+                values[index] = [];
+                errors.push(`${names[index]}: ${errorMessage(entry.reason)}`);
+            }
+        });
+        return { values, errors };
+    };
+    const overview = async () => {
+        const names = ["servers", "projects", "applications", "databases", "services"];
+        const { values, errors } = 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 } : {}) };
+    };
+    const batch = async (resources, action) => {
+        const settled = await Promise.allSettled(resources.map(action));
+        const succeeded = [];
+        const failed = [];
+        settled.forEach((entry, index) => {
+            const resource = resources[index];
+            const item = { uuid: resource.uuid, name: resource.name ?? resource.uuid };
+            if (entry.status === "fulfilled")
+                succeeded.push(item);
+            else
+                failed.push({ ...item, error: errorMessage(entry.reason) });
+        });
+        return { summary: { total: resources.length, succeeded: succeeded.length, failed: failed.length }, succeeded, failed };
+    };
+    const application = async (query) => {
+        const apps = rows(await call("coolify_list_applications"));
+        return apps.find((app) => [app.uuid, app.name, app.fqdn].some((value) => typeof value === "string" && value.toLowerCase().includes(query.toLowerCase())));
+    };
+    const serverByQuery = async (query) => {
+        const servers = rows(await call("coolify_list_servers"));
+        return servers.find((item) => [item.uuid, item.name, item.ip].some((value) => typeof value === "string" && value.toLowerCase().includes(query.toLowerCase())));
+    };
+    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_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;
+        try {
+            app = await application(String(query));
+        }
+        catch (error) {
+            return { application: null, health: { status: "unknown", issues: [] }, logs: null, environment_variables: { count: 0, variables: [] }, recent_deployments: [], errors: [errorMessage(error)] };
+        }
+        if (!app?.uuid)
+            return { application: null, health: { status: "unknown", issues: [] }, logs: null, environment_variables: { count: 0, variables: [] }, recent_deployments: [], errors: [`No application found matching ${query}`] };
+        const names = ["application", "logs", "environment_variables", "deployments"];
+        const settled = await Promise.allSettled([
+            call("coolify_get_application_by_uuid", { uuid: app.uuid }), call("coolify_get_application_logs_by_uuid", { uuid: app.uuid, lines: 50 }), call("coolify_list_envs_by_application_uuid", { uuid: app.uuid }), call("coolify_list_deployments_by_app_uuid", { uuid: app.uuid }),
+        ]);
+        const errors = [];
+        const value = (index) => { const entry = settled[index]; if (entry.status === "fulfilled")
+            return entry.value; errors.push(`${names[index]}: ${errorMessage(entry.reason)}`); return null; };
+        const details = value(0);
+        const rawLogs = value(1);
+        const envVars = environmentSummary(value(2));
+        const deployments = rows(value(3));
+        const appInfo = details ?? app;
+        const appStatus = status(appInfo);
+        const issues = [];
+        let health = "unknown";
+        if (/exited|unhealthy|error/iu.test(appStatus)) {
+            health = "unhealthy";
+            issues.push(`Status: ${appStatus}`);
+        }
+        else if (/running/iu.test(appStatus))
+            health = "healthy";
+        const failed = deployments.slice(0, 5).filter((item) => item.status === "failed").length;
+        if (failed) {
+            health = "unhealthy";
+            issues.push(`${failed} failed deployment(s) in last 5`);
+        }
+        const logs = typeof rawLogs === "string" ? rawLogs : rawLogs && typeof rawLogs === "object" && typeof rawLogs.logs === "string" ? rawLogs.logs : null;
+        return { application: { uuid: appInfo.uuid, name: appInfo.name, status: appStatus || "unknown", fqdn: appInfo.fqdn ?? null, git_repository: appInfo.git_repository ?? null, git_branch: appInfo.git_branch ?? null }, health: { status: health, issues }, logs: logs === null ? null : truncateLogs(logs), environment_variables: { count: envVars.length, variables: envVars }, recent_deployments: deployments.slice(0, 5).map((item) => ({ uuid: item.uuid, status: item.status, created_at: item.created_at })), ...(errors.length ? { errors } : {}) };
+    });
+    register("coolify_diagnose_server", "Diagnose a server by UUID, name, or IP.", z.object({ query: z.string() }), { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async ({ query }) => {
+        let found;
+        try {
+            found = await serverByQuery(String(query));
+        }
+        catch (error) {
+            return { server: null, health: { status: "unknown", issues: [] }, resources: [], domains: [], validation: null, errors: [errorMessage(error)] };
+        }
+        if (!found?.uuid)
+            return { server: null, health: { status: "unknown", issues: [] }, resources: [], domains: [], validation: null, errors: [`No server found matching ${query}`] };
+        const names = ["server", "resources", "domains", "validation"];
+        const settled = await Promise.allSettled([
+            call("coolify_get_server_by_uuid", { uuid: found.uuid }), call("coolify_get_resources_by_server_uuid", { uuid: found.uuid }), call("coolify_get_domains_by_server_uuid", { uuid: found.uuid }), call("coolify_validate_server_by_uuid", { uuid: found.uuid }),
+        ]);
+        const errors = [];
+        const value = (index) => { const entry = settled[index]; if (entry.status === "fulfilled")
+            return entry.value; errors.push(`${names[index]}: ${errorMessage(entry.reason)}`); return null; };
+        const details = value(0) ?? found;
+        const resources = rows(value(1));
+        const issues = [];
+        if (details.is_reachable === false)
+            issues.push("Server is not reachable");
+        if (details.is_usable === false)
+            issues.push("Server is not usable");
+        const unhealthyResources = resources.filter(unhealthy).length;
+        if (unhealthyResources)
+            issues.push(`${unhealthyResources} unhealthy resource(s)`);
+        return { server: { uuid: details.uuid, name: details.name, ip: details.ip, status: details.status ?? null, is_reachable: details.is_reachable ?? null }, health: { status: issues.length ? "unhealthy" : details.is_reachable === true ? "healthy" : "unknown", issues }, resources: resources.map((item) => ({ uuid: item.uuid, name: item.name, type: item.type, status: item.status })), domains: rows(value(2)), validation: value(3), ...(errors.length ? { errors } : {}) };
+    });
+    register("coolify_find_issues", "Find unhealthy Coolify infrastructure.", z.object({}), { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async () => {
+        const names = ["servers", "applications", "databases", "services"];
+        const { values, errors } = await settledRows(names);
+        const issues = [];
+        values[0].forEach((item) => { if (item.is_reachable === false || item.is_usable === false)
+            issues.push({ type: "server", uuid: item.uuid, name: item.name, issue: item.is_reachable === false ? "Server is not reachable" : "Server is not usable", status: status(item) || "unreachable" }); });
+        values.slice(1).forEach((items, index) => items.filter(unhealthy).forEach((item) => issues.push({ type: names[index + 1].slice(0, -1), uuid: item.uuid, name: item.name, issue: `${names[index + 1].slice(0, -1)} status: ${status(item)}`, status: status(item) })));
+        return { summary: { total_issues: issues.length, unhealthy_applications: issues.filter((item) => item.type === "application").length, unhealthy_databases: issues.filter((item) => item.type === "database").length, unhealthy_services: issues.filter((item) => item.type === "service").length, unreachable_servers: issues.filter((item) => item.type === "server").length }, issues, ...(errors.length ? { errors } : {}) };
+    });
+    register("coolify_restart_project_applications", "Restart every application in a project.", z.object({ project_uuid: z.string() }), { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }, async ({ project_uuid }) => batch(rows(await call("coolify_list_applications")).filter((app) => app.project_uuid === project_uuid), (app) => call("coolify_restart_application_by_uuid", { uuid: app.uuid })));
+    register("coolify_bulk_update_application_env", "Update an environment variable across applications.", z.object({ app_uuids: z.array(z.string()), key: z.string(), value: z.string() }).strict(), { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }, async ({ app_uuids, key, value }) => {
+        if (!app_uuids.length)
+            return batch([], async () => undefined);
+        const names = rows(await call("coolify_list_applications"));
+        const labels = new Map(names.map((item) => [item.uuid, item.name ?? item.uuid]));
+        return batch(app_uuids.map((uuid) => ({ uuid, name: labels.get(uuid) ?? uuid })), (app) => call("coolify_update_env_by_application_uuid", { uuid: app.uuid, body: { key, value } }));
+    });
+    register("coolify_stop_all_applications", "Emergency stop every running application.", z.object({ confirm_stop_all_applications: z.literal(true) }), { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }, async () => batch(rows(await call("coolify_list_applications")).filter((app) => /running|healthy/iu.test(status(app))), (app) => call("coolify_stop_application_by_uuid", { uuid: app.uuid })));
+    register("coolify_redeploy_project_applications", "Redeploy every application in a project.", z.object({ project_uuid: z.string(), force: z.boolean().optional() }), { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }, async ({ project_uuid, force }) => batch(rows(await call("coolify_list_applications")).filter((app) => app.project_uuid === project_uuid), (app) => call("coolify_deploy_by_tag_or_uuid", { uuid: app.uuid, force: force ?? true })));
+    register("coolify_get_environment", "Get an environment and its relevant database types.", z.object({ project_uuid: z.string(), environment_name_or_uuid: z.string() }), { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async ({ project_uuid, environment_name_or_uuid }) => {
+        const settled = await Promise.allSettled([call("coolify_get_environment_by_name_or_uuid", { uuid: project_uuid, environment_name_or_uuid }), call("coolify_list_databases")]);
+        const errors = [];
+        const environment = settled[0].status === "fulfilled" ? settled[0].value : (errors.push(`environment: ${errorMessage(settled[0].reason)}`), null);
+        const databases = settled[1].status === "fulfilled" ? rows(settled[1].value) : (errors.push(`databases: ${errorMessage(settled[1].reason)}`), []);
+        if (!environment)
+            return { environment: null, missing_database_types: [...databaseTypes], ...(errors.length ? { errors } : {}) };
+        const matching = databases.filter((database) => (environment.id !== undefined && database.environment_id === environment.id) || (environment.uuid !== undefined && database.environment_uuid === environment.uuid) || (environment.name !== undefined && database.environment_name === environment.name));
+        const byType = new Map();
+        matching.forEach((database) => { const type = String(database.database_type ?? database.type ?? "").toLowerCase(); for (const expected of databaseTypes)
+            if (type.includes(expected))
+                byType.set(expected, [...(byType.get(expected) ?? []), database]); });
+        const missing = databaseTypes.filter((type) => !byType.has(type));
+        return { ...environment, ...Object.fromEntries(databaseTypes.filter((type) => byType.has(type)).map((type) => [`${type}s`, byType.get(type)])), missing_database_types: missing, ...(errors.length ? { errors } : {}) };
+    });
+    register("coolify_docker_network_alias", "Generate Docker network alias remediation commands.", z.object({ server_uuid: z.string().regex(/^[a-zA-Z0-9-]{1,64}$/u), db_uuid: z.string().regex(/^[a-zA-Z0-9-]{1,64}$/u), name: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,62}$/u), network: z.string().optional() }), { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async ({ server_uuid, db_uuid, name, network = "coolify" }) => {
+        const server = await call("coolify_get_server_by_uuid", { uuid: server_uuid }).catch(() => null);
+        const quote = (value) => `'${value.replace(/'/gu, "'\\''")}'`;
+        return { bug: "Coolify database containers may require a friendly Docker network alias.", warning: "The alias is lost after a rebuild or redeploy.", ...(server ? { server: { ip: server.ip, user: server.user, port: server.port } } : { server_lookup_failed: "Could not retrieve server details" }), commands: { ssh_connect: server ? `ssh -p ${server.port} ${server.user}@${server.ip}` : "ssh -p <port> <user>@<server-ip>", add_alias: [`docker network disconnect ${quote(String(network))} ${quote(String(db_uuid))}`, `docker network connect ${quote(String(network))} ${quote(String(db_uuid))} --alias ${quote(String(name))} --alias ${quote(String(db_uuid))}`], verify: `docker exec <any-app-container> getent hosts ${quote(String(name))}` }, next_actions: [{ tool: "coolify_get_database_by_uuid", args: { uuid: db_uuid }, hint: "Check database status" }] };
+    });
+}

package/dist/client.d.ts

@@ -0,0 +1,26 @@
+import type { GeneratedOperation } from "./generated/operations.js";
+import type { CoolifyConfig } from "./config.js";
+import { CoolifyApiError } from "./errors.js";
+export interface ToolEnvelope<T> {
+    data: T;
+    status: number;
+    request: {
+        method: string;
+        path: string;
+    };
+}
+export interface BinaryEnvelope {
+    encoding: "base64";
+    contentType: string;
+    value: string;
+}
+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 class CoolifyClient {
+    private readonly config;
+    private readonly fetchImpl;
+    constructor(config: CoolifyConfig, fetchImpl?: FetchLike);
+    request<T>(operation: Operation, input: Record<string, unknown>): Promise<ToolEnvelope<T | null | string | BinaryEnvelope>>;
+}
+export { CoolifyApiError };

package/dist/client.js

@@ -0,0 +1,95 @@
+import { CoolifyApiError } from "./errors.js";
+const sensitiveKey = /(^value$|real_?value|private_?key|token|secret|password|authorization|cookie)/iu;
+export function redactSensitive(value) {
+    if (Array.isArray(value))
+        return value.map(redactSensitive);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+        key,
+        sensitiveKey.test(key) ? "[REDACTED]" : redactSensitive(child),
+    ]));
+}
+function pathValue(value, name) {
+    if (value === undefined || value === null)
+        throw new Error(`Missing required path parameter: ${name}`);
+    return encodeURIComponent(String(value));
+}
+function appendQuery(url, name, value) {
+    if (value === undefined || value === null)
+        return;
+    if (Array.isArray(value))
+        for (const item of value)
+            url.searchParams.append(name, String(item));
+    else
+        url.searchParams.set(name, typeof value === "object" ? JSON.stringify(value) : String(value));
+}
+function base64(bytes) {
+    let text = "";
+    for (const byte of new Uint8Array(bytes))
+        text += String.fromCharCode(byte);
+    return btoa(text);
+}
+function normalizeKnownCollection(path, value) {
+    const collectionPaths = new Set(["/databases", "/resources", "/deployments", "/deployments/applications/{uuid}"]);
+    if (!collectionPaths.has(path))
+        return value;
+    if (Array.isArray(value))
+        return value;
+    if (!value || typeof value !== "object")
+        throw new Error(`Coolify collection response for ${path} must be an array or named array wrapper`);
+    for (const key of ["data", "items", "results", "databases", "resources", "deployments"]) {
+        const nested = value[key];
+        if (Array.isArray(nested))
+            return nested;
+    }
+    throw new Error(`Coolify collection response for ${path} must be an array or named array wrapper`);
+}
+export class CoolifyClient {
+    config;
+    fetchImpl;
+    constructor(config, fetchImpl = fetch) {
+        this.config = config;
+        this.fetchImpl = fetchImpl;
+    }
+    async request(operation, input) {
+        let path = operation.path;
+        for (const parameter of operation.parameters)
+            if (parameter.location === "path") {
+                path = path.replace(`{${parameter.name}}`, pathValue(input[parameter.name], parameter.name));
+            }
+        if (path.includes("{"))
+            throw new Error(`Unresolved path parameter in ${operation.path}`);
+        const url = new URL(this.config.baseUrl + path);
+        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 ${this.config.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");
+            init.body = JSON.stringify(input.body);
+        }
+        let response;
+        try {
+            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(this.config.token, "[REDACTED]") : "request error"}`);
+        }
+        if (!response.ok)
+            throw new CoolifyApiError(response.status, operation.method, path, `Coolify API returned ${response.status} for ${operation.method} ${path}`);
+        let data = null;
+        if (response.status !== 204) {
+            const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+            if (contentType.includes("json"))
+                data = normalizeKnownCollection(operation.path, await response.json());
+            else if (contentType.startsWith("text/") || contentType.includes("xml"))
+                data = await response.text();
+            else
+                data = { encoding: "base64", contentType: contentType || "application/octet-stream", value: base64(await response.arrayBuffer()) };
+        }
+        return redactSensitive({ data, status: response.status, request: { method: operation.method, path } });
+    }
+}
+export { CoolifyApiError };

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+export interface CoolifyConfig {
+    baseUrl: string;
+    token: string;
+    timeoutMs: number;
+}
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+export declare function loadConfig(env?: Record<string, string | undefined>): CoolifyConfig;

package/dist/config.js

@@ -0,0 +1,30 @@
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+    }
+}
+export function loadConfig(env = process.env) {
+    const rawUrl = env.COOLIFY_URL?.trim();
+    const token = env.COOLIFY_TOKEN?.trim();
+    if (!rawUrl)
+        throw new ConfigError("COOLIFY_URL is required");
+    if (!token)
+        throw new ConfigError("COOLIFY_TOKEN is required");
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        throw new ConfigError("COOLIFY_URL must be a valid HTTP(S) URL");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new ConfigError("COOLIFY_URL must use http:// or https://");
+    }
+    if (url.search || url.hash)
+        throw new ConfigError("COOLIFY_URL must not include a query or fragment");
+    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, timeoutMs: 30_000 };
+}

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class CoolifyApiError extends Error {
+    readonly status: number;
+    readonly method: string;
+    readonly path: string;
+    constructor(status: number, method: string, path: string, message: string);
+}

package/dist/errors.js

@@ -0,0 +1,12 @@
+export class CoolifyApiError extends Error {
+    status;
+    method;
+    path;
+    constructor(status, method, path, message) {
+        super(message);
+        this.status = status;
+        this.method = method;
+        this.path = path;
+        this.name = "CoolifyApiError";
+    }
+}