@mks2508/coolify-mks-cli-mcp 0.8.0 → 0.9.0

package/dist/server/stdio.js

@@ -1,31 +1,51 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../../node_modules/.bun/ajv@8.17.1/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS((exports) => {
@@ -6277,7 +6297,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time(str) {
+    return function time3(str) {
       const matches = TIME.exec(str);
       if (!matches)
         return false;
@@ -12971,6 +12991,11 @@ Redeploy after updating to apply changes.`,
           type: "string",
           description: 'Base directory for build context (default: "/")'
         },
+        watchPaths: {
+          type: "string",
+          description: 'Watch paths for selective auto-deploy. Newline-separated globs (e.g. "src/**\\npackages/**"). Set to empty string or null to clear.',
+          nullable: true
+        },
         dockerComposeDomains: {
           type: "string",
           description: 'Docker Compose domains JSON: { "service-name": { "domain": "https://..." } }'
@@ -12979,6 +13004,22 @@ Redeploy after updating to apply changes.`,
       required: ["uuid"]
     }
   },
+  {
+    name: "get_application",
+    description: `Get detailed information about a Coolify application including settings (auto-deploy, force HTTPS) and watch paths.
+
+Returns full application details that list_applications doesn't include.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        uuid: {
+          type: "string",
+          description: "Application UUID"
+        }
+      },
+      required: ["uuid"]
+    }
+  },
   {
     name: "set_domains",
     description: `Set domains/FQDN for a Coolify application.
@@ -18445,6 +18486,7 @@ async function loadConfig() {
     return err(error2 instanceof Error ? error2 : new Error(String(error2)));
   }
 }
+var SETTINGS_CACHE_FILE = join(CONFIG_DIR, "app-settings-cache.json");
 
 // src/coolify/index.ts
 var log = component("CoolifyService");
@@ -18506,7 +18548,10 @@ class CoolifyService {
       let data;
       try {
         data = text ? JSON.parse(text) : undefined;
-      } catch {
+      } catch (parseErr) {
+        const preview = text ? text.slice(0, 200) : "(empty body)";
+        const method = options.method ?? "GET";
+        log.warn(`Failed to parse JSON response from ${method} ${endpoint} (status ${response.status}): ${parseErr instanceof Error ? parseErr.message : String(parseErr)}. Body preview: ${preview}`);
         if (!response.ok) {
           return {
             error: text || `HTTP ${response.status}`,
@@ -18514,6 +18559,11 @@ class CoolifyService {
             durationMs
           };
         }
+        return {
+          error: `Response was not valid JSON (status ${response.status}): ${preview}`,
+          status: response.status,
+          durationMs
+        };
       }
       if (!response.ok) {
         const parsed = data;
@@ -18580,8 +18630,8 @@ class CoolifyService {
       "private-github-app": "/applications/private-github-app",
       "private-deploy-key": "/applications/private-deploy-key",
       dockerfile: "/applications/dockerfile",
-      "docker-image": "/applications/docker-image",
-      "docker-compose": "/applications/docker-compose",
+      "docker-image": "/applications/dockerimage",
+      "docker-compose": "/applications/dockercompose",
       dockerimage: "/applications/dockerimage",
       dockercompose: "/applications/dockercompose"
     };
@@ -18591,33 +18641,40 @@ class CoolifyService {
       description: options.description,
       project_uuid: options.projectUuid,
       environment_uuid: options.environmentUuid,
+      environment_name: options.environmentName,
       server_uuid: options.serverUuid
     };
     if (options.githubRepoUrl) {
-      body.git_repository = options.githubRepoUrl.replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
+      body.git_repository = options.githubRepoUrl;
     }
     if (appType === "public" || appType === "private-github-app" || appType === "private-deploy-key") {
       if (options.githubAppUuid) {
         body.github_app_uuid = options.githubAppUuid;
       }
+      if (appType === "private-deploy-key" && options.privateKeyUuid) {
+        body.private_key_uuid = options.privateKeyUuid;
+      }
       body.git_branch = options.branch || "main";
       body.build_pack = options.buildPack || "dockerfile";
       if (options.portsExposes) {
         body.ports_exposes = options.portsExposes;
       }
       if (options.dockerfileLocation) {
-        body.dockerfile_location = options.dockerfileLocation;
+        const p = options.dockerfileLocation;
+        body.dockerfile_location = p.startsWith("/") ? p : `/${p}`;
       }
       if (options.dockerComposeLocation) {
-        body.docker_compose_location = options.dockerComposeLocation;
+        const p = options.dockerComposeLocation;
+        body.docker_compose_location = p.startsWith("/") ? p : `/${p}`;
       }
       if (options.baseDirectory) {
-        body.base_directory = options.baseDirectory;
+        const p = options.baseDirectory;
+        body.base_directory = p.startsWith("/") ? p : `/${p}`;
       }
     } else if (appType === "docker-image" && options.dockerImage) {
-      body.docker_image = options.dockerImage;
+      body.docker_registry_image_name = options.dockerImage;
     } else if (appType === "docker-compose" && options.dockerCompose) {
-      body.docker_compose = options.dockerCompose;
+      body.docker_compose_raw = options.dockerCompose;
     }
     log.debug(`Create application body: ${JSON.stringify(body, null, 2)}`);
     log.debug(`Endpoint: POST ${endpoint}`);
@@ -18638,37 +18695,17 @@ class CoolifyService {
   }
   async setEnvironmentVariables(appUuid, envVars) {
     log.info(`Setting ${Object.keys(envVars).length} environment variables for ${appUuid}`);
-    for (const [key, value] of Object.entries(envVars)) {
-      const result = await this.request(`/applications/${appUuid}/envs`, {
-        method: "POST",
-        body: JSON.stringify({ key, value, is_preview: false, is_buildtime: false })
-      });
-      if (result.error && result.error.includes("already exists")) {
-        const listResult = await this.request(`/applications/${appUuid}/envs`);
-        const existing = listResult.data?.find((v) => v.key === key);
-        if (existing) {
-          await this.request(`/applications/${appUuid}/envs/${existing.uuid}`, {
-            method: "DELETE"
-          });
-          const repost = await this.request(`/applications/${appUuid}/envs`, {
-            method: "POST",
-            body: JSON.stringify({ key, value, is_preview: false, is_buildtime: false })
-          });
-          if (repost.error) {
-            log.error(`Failed to update env var ${key}: ${repost.error}`);
-            return err(new Error(`Failed to update ${key}: ${repost.error}`));
-          }
-          log.debug(`Updated existing env var: ${key}`);
-        } else {
-          log.error(`Failed to set env var ${key}: ${result.error}`);
-          return err(new Error(`Failed to set ${key}: ${result.error}`));
-        }
-      } else if (result.error) {
-        log.error(`Failed to set env var ${key}: ${result.error}`);
-        return err(new Error(`Failed to set ${key}: ${result.error}`));
-      }
+    const vars = Object.entries(envVars).map(([key, value]) => ({
+      key,
+      value,
+      is_buildtime: false,
+      is_runtime: true
+    }));
+    const result = await this.bulkUpdateEnvironmentVariables(appUuid, vars);
+    if (isErr(result)) {
+      return err(result.error);
     }
-    log.success(`${Object.keys(envVars).length} environment variables set`);
+    log.success(`${vars.length} environment variables set`);
     return ok(undefined);
   }
   async getEnvironmentVariables(appUuid) {
@@ -18683,39 +18720,16 @@ class CoolifyService {
   }
   async setEnvironmentVariable(appUuid, key, value, isBuildTime = false) {
     log.info(`Setting environment variable ${key} for ${appUuid} (buildtime: ${isBuildTime})`);
-    const existingVars = await this.getEnvironmentVariables(appUuid);
-    if (isErr(existingVars)) {
-      return err(existingVars.error);
-    }
-    const exists = existingVars.value.some((ev) => ev.key === key);
-    if (exists) {
-      log.debug(`Variable ${key} exists, using PATCH to update`);
-      const result = await this.request(`/applications/${appUuid}/envs`, {
-        method: "PATCH",
-        body: JSON.stringify({
-          key,
-          value,
-          is_buildtime: isBuildTime
-        })
-      });
-      if (result.error) {
-        log.error(`Failed to update env var: ${result.error}`);
-        return err(new Error(result.error));
-      }
-    } else {
-      log.debug(`Variable ${key} does not exist, using POST to create`);
-      const result = await this.request(`/applications/${appUuid}/envs`, {
-        method: "POST",
-        body: JSON.stringify({
-          key,
-          value,
-          is_buildtime: isBuildTime
-        })
-      });
-      if (result.error) {
-        log.error(`Failed to create env var: ${result.error}`);
-        return err(new Error(result.error));
+    const result = await this.bulkUpdateEnvironmentVariables(appUuid, [
+      {
+        key,
+        value,
+        is_buildtime: isBuildTime,
+        is_runtime: !isBuildTime
       }
+    ]);
+    if (isErr(result)) {
+      return err(result.error);
     }
     log.success(`Environment variable ${key} set for ${appUuid}`);
     return ok(undefined);
@@ -18789,6 +18803,23 @@ class CoolifyService {
       return err(new Error(result.error));
     return ok(result.data || []);
   }
+  async listGithubAppsAll(perPage = 50) {
+    const allApps = [];
+    let page = 1;
+    while (true) {
+      const result = await this.listGithubApps(page, perPage);
+      if (isErr(result))
+        return err(result.error);
+      const apps = result.value;
+      if (apps.length === 0)
+        break;
+      allApps.push(...apps);
+      if (apps.length < perPage)
+        break;
+      page++;
+    }
+    return ok(allApps);
+  }
   async listProjects(page, perPage) {
     let endpoint = "/projects";
     const params = new URLSearchParams;
@@ -18924,10 +18955,14 @@ class CoolifyService {
       body.domains = options.domains;
     if (options.dockerComposeDomains)
       body.docker_compose_domains = options.dockerComposeDomains;
+    if (options.dockerComposeRaw !== undefined)
+      body.docker_compose_raw = options.dockerComposeRaw;
     if (options.isForceHttpsEnabled !== undefined)
       body.is_force_https_enabled = options.isForceHttpsEnabled;
     if (options.isAutoDeployEnabled !== undefined)
       body.is_auto_deploy_enabled = options.isAutoDeployEnabled;
+    if (options.watchPaths !== undefined)
+      body.watch_paths = options.watchPaths;
     if (options.healthCheckEnabled !== undefined)
       body.health_check_enabled = options.healthCheckEnabled;
     if (options.healthCheckPath)
@@ -18998,7 +19033,7 @@ class CoolifyService {
     log.info(`Bulk updating ${envVars.length} env vars for ${appUuid}`);
     const result = await this.request(`/applications/${appUuid}/envs/bulk`, {
       method: "PATCH",
-      body: JSON.stringify(envVars)
+      body: JSON.stringify({ data: envVars })
     });
     if (result.error) {
       log.error(`Failed to bulk update env vars: ${result.error}`);
@@ -19007,6 +19042,19 @@ class CoolifyService {
     log.success(`Bulk updated ${envVars.length} env vars for ${appUuid}`);
     return ok(result.data || { message: "Environment variables updated" });
   }
+  async bulkUpdateDatabaseEnvVars(databaseUuid, envVars) {
+    log.info(`Bulk updating ${envVars.length} env vars for database ${databaseUuid}`);
+    const result = await this.request(`/databases/${databaseUuid}/envs/bulk`, {
+      method: "PATCH",
+      body: JSON.stringify({ data: envVars })
+    });
+    if (result.error) {
+      log.error(`Failed to bulk update database env vars: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    log.success(`Bulk updated ${envVars.length} env vars for database ${databaseUuid}`);
+    return ok(result.data || { message: "Environment variables updated" });
+  }
   async getApplicationDeploymentHistory(appUuid) {
     log.info(`Getting deployment history for ${appUuid}`);
     const result = await this.request(`/deployments/applications/${appUuid}`);
@@ -19426,12 +19474,76 @@ class CoolifyService {
       return err(new Error(result.error));
     return ok(result.data || []);
   }
+  async bulkUpdateServiceEnvVars(serviceUuid, envVars) {
+    log.info(`Bulk updating ${envVars.length} env vars for service ${serviceUuid}`);
+    const result = await this.request(`/services/${serviceUuid}/envs/bulk`, {
+      method: "PATCH",
+      body: JSON.stringify({ data: envVars })
+    });
+    if (result.error) {
+      log.error(`Failed to bulk update service env vars: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    log.success(`Bulk updated ${envVars.length} env vars for service ${serviceUuid}`);
+    return ok(result.data || { message: "Environment variables updated" });
+  }
   async createServiceEnvVar(uuid2, data) {
     const result = await this.request(`/services/${uuid2}/envs`, { method: "POST", body: JSON.stringify(data) });
     if (result.error)
       return err(new Error(result.error));
     return ok(result.data);
   }
+  async deleteServiceEnvVar(serviceUuid, key) {
+    log.info(`Deleting environment variable ${key} from service ${serviceUuid}`);
+    const envVarsResult = await this.listServiceEnvVars(serviceUuid);
+    if (isErr(envVarsResult)) {
+      return err(envVarsResult.error);
+    }
+    const envVar = envVarsResult.value.find((ev) => ev.key === key);
+    if (!envVar) {
+      log.error(`Environment variable ${key} not found on service ${serviceUuid}`);
+      return err(new Error(`Environment variable ${key} not found`));
+    }
+    const result = await this.request(`/services/${serviceUuid}/envs/${envVar.uuid}`, {
+      method: "DELETE"
+    });
+    if (result.error) {
+      log.error(`Failed to delete service env var: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    log.success(`Environment variable ${key} deleted from service ${serviceUuid}`);
+    return ok(undefined);
+  }
+  async listDatabaseEnvVars(databaseUuid) {
+    log.info(`Listing env vars for database ${databaseUuid}`);
+    const result = await this.request(`/databases/${databaseUuid}/envs`);
+    if (result.error) {
+      log.error(`Failed to list database env vars: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    return ok(result.data || []);
+  }
+  async deleteDatabaseEnvVar(databaseUuid, key) {
+    log.info(`Deleting environment variable ${key} from database ${databaseUuid}`);
+    const envVarsResult = await this.listDatabaseEnvVars(databaseUuid);
+    if (isErr(envVarsResult)) {
+      return err(envVarsResult.error);
+    }
+    const envVar = envVarsResult.value.find((ev) => ev.key === key);
+    if (!envVar) {
+      log.error(`Environment variable ${key} not found on database ${databaseUuid}`);
+      return err(new Error(`Environment variable ${key} not found`));
+    }
+    const result = await this.request(`/databases/${databaseUuid}/envs/${envVar.uuid}`, {
+      method: "DELETE"
+    });
+    if (result.error) {
+      log.error(`Failed to delete database env var: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    log.success(`Environment variable ${key} deleted from database ${databaseUuid}`);
+    return ok(undefined);
+  }
   async getServerResources(serverUuid) {
     log.info(`Getting resources for server ${serverUuid}`);
     const result = await this.request(`/servers/${serverUuid}/resources`);
@@ -19948,6 +20060,28 @@ Please use the full UUID.`));
   }
 }
 
+// src/utils/env-parser.ts
+function parseEnvContent(content) {
+  const envVars = new Map;
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1)
+      continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key)
+      envVars.set(key, value);
+  }
+  return envVars;
+}
+
 // src/sdk.ts
 function unwrap(result) {
   if (isErr(result))
@@ -19966,6 +20100,9 @@ class ApplicationsResource {
   async listSummaries() {
     return unwrap(await this.svc.listApplicationSummaries());
   }
+  async get(uuid2) {
+    return unwrap(await this.svc.getApplication(uuid2));
+  }
   async resolve(query) {
     return unwrap(await this.svc.resolveApplication(query));
   }
@@ -20014,10 +20151,15 @@ class ApplicationsResource {
   async syncEnv(uuid2, options = {}) {
     const { filePath, dryRun = false, prune = false, onProgress } = options;
     let envContent;
+    const { readFileSync } = await import("node:fs");
+    const { resolve, isAbsolute } = await import("node:path");
+    const target = filePath || ".env";
+    const absoluteTarget = isAbsolute(target) ? target : resolve(process.cwd(), target);
     try {
-      envContent = await Bun.file(filePath || ".env").text();
-    } catch {
-      throw new Error(filePath ? `Cannot read file: ${filePath}` : "No .env file found in current directory");
+      envContent = readFileSync(absoluteTarget, "utf-8");
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      throw new Error(`Cannot read env file at ${absoluteTarget} (resolved from ${target}): ${msg}`);
     }
     const localVars = this.parseEnvContent(envContent);
     if (localVars.size === 0) {
@@ -20075,26 +20217,7 @@ class ApplicationsResource {
     };
   }
   parseEnvContent(content) {
-    const envVars = new Map;
-    const lines = content.split(`
-`);
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-      if (!trimmedLine || trimmedLine.startsWith("#")) {
-        continue;
-      }
-      const eqIndex = trimmedLine.indexOf("=");
-      if (eqIndex === -1) {
-        continue;
-      }
-      const key = trimmedLine.slice(0, eqIndex).trim();
-      let value = trimmedLine.slice(eqIndex + 1).trim();
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-        value = value.slice(1, -1);
-      }
-      envVars.set(key, value);
-    }
-    return envVars;
+    return parseEnvContent(content);
   }
 }
 
@@ -20142,6 +20265,15 @@ class DatabasesResource {
   async deleteBackup(dbUuid, backupUuid) {
     return unwrap(await this.svc.deleteDatabaseBackup(dbUuid, backupUuid));
   }
+  async envVars(uuid2) {
+    return unwrap(await this.svc.listDatabaseEnvVars(uuid2));
+  }
+  async bulkSetEnv(uuid2, vars) {
+    return unwrap(await this.svc.bulkUpdateDatabaseEnvVars(uuid2, vars));
+  }
+  async deleteEnv(uuid2, key) {
+    return unwrap(await this.svc.deleteDatabaseEnvVar(uuid2, key));
+  }
 }
 
 class ServicesResource {
@@ -20180,7 +20312,13 @@ class ServicesResource {
     return unwrap(await this.svc.listServiceEnvVars(uuid2));
   }
   async setEnv(uuid2, data) {
-    return unwrap(await this.svc.createServiceEnvVar(uuid2, data));
+    return unwrap(await this.svc.bulkUpdateServiceEnvVars(uuid2, [data]));
+  }
+  async bulkSetEnv(uuid2, vars) {
+    return unwrap(await this.svc.bulkUpdateServiceEnvVars(uuid2, vars));
+  }
+  async deleteEnv(uuid2, key) {
+    return unwrap(await this.svc.deleteServiceEnvVar(uuid2, key));
   }
 }
 
@@ -20514,11 +20652,26 @@ async function handleToolCall(name, args) {
         startCommand: a.startCommand,
         domains: a.domains,
         isForceHttpsEnabled: a.isForceHttpsEnabled,
-        isAutoDeployEnabled: a.isAutoDeployEnabled
+        isAutoDeployEnabled: a.isAutoDeployEnabled,
+        watchPaths: a.watchPaths
       }).then((app) => ({
         message: `Application ${a.uuid} updated`,
         application: app
       })), "Failed to update application");
+    case "get_application":
+      return mcpCall((s) => s.applications.get(a.uuid).then((app) => ({
+        uuid: app.uuid,
+        name: app.name,
+        status: app.status,
+        fqdn: app.fqdn,
+        git_repository: app.git_repository,
+        git_branch: app.git_branch,
+        build_pack: app.build_pack,
+        dockerfile_location: app.dockerfile_location,
+        base_directory: app.base_directory,
+        watch_paths: app.watch_paths,
+        settings: app.settings
+      })), "Failed to get application");
     case "get_application_logs":
       return mcpCall((s) => s.applications.logs(a.uuid, { tail: a.tail, serviceName: a.serviceName }).then((logs) => ({
         timestamp: logs.timestamp,

package/dist/tools/definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/tools/definitions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,IAAI,EAmqC9B,CAAC"}
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/tools/definitions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,IAAI,EAyrC9B,CAAC"}

package/dist/tools/handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/tools/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AA+DzE;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,cAAc,CAAC,CAgfzB"}
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/tools/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AA+DzE;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,cAAc,CAAC,CAmgBzB"}

package/dist/utils/env-parser.d.ts

@@ -0,0 +1,24 @@
+/**
+ * .env file parser shared between the SDK (syncEnv) and the CLI (--sync stdin).
+ *
+ * Kept as a standalone exported function (not a class method) so both the
+ * SDK's ApplicationsResource and the CLI's stdin sync handler can use the
+ * same implementation without coupling to either.
+ *
+ * @module
+ */
+/**
+ * Parses .env-style content into a Map.
+ *
+ * Handles:
+ * - Comments (lines starting with `#`)
+ * - Empty lines (skipped)
+ * - Quoted values (`"value"` or `'value'`)
+ * - Values containing `=` (only the first `=` is the separator)
+ * - Lines without `=` (skipped — invalid)
+ *
+ * @param content - File contents in KEY=VALUE format
+ * @returns Map of key → value (empty string for `KEY=` with no value)
+ */
+export declare function parseEnvContent(content: string): Map<string, string>;
+//# sourceMappingURL=env-parser.d.ts.map

package/dist/utils/env-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-parser.d.ts","sourceRoot":"","sources":["../../src/utils/env-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAqBpE"}

package/dist/utils/format.d.ts

@@ -28,6 +28,38 @@ export declare function formatStatus(status: string): string;
  * @returns Formatted string with unit
  */
 export declare function formatBytes(bytes: number): string;
+/**
+ * Validates a port number string (single or comma-separated).
+ * Valid: "3000", "3000,3001", "80,443,8080"
+ * Invalid: "abc", "99999", "0", "-1", "3000,", ",3000"
+ *
+ * @param ports - Port string to validate
+ * @returns Object with valid flag, parsed ports, and error message
+ */
+export declare function validatePorts(ports: string): {
+    valid: boolean;
+    ports: number[];
+    error?: string;
+};
+/**
+ * Parses EXPOSE directives from a Dockerfile.
+ *
+ * @param dockerfilePath - Path to the Dockerfile
+ * @returns Array of exposed port numbers, empty if none found or file unreadable
+ */
+export declare function parseDockerfileExpose(dockerfilePath: string): number[];
+/**
+ * Validates a .coolify.json state object (single-app format).
+ * Checks required fields, types, and port validity.
+ *
+ * @param state - The parsed JSON object
+ * @returns Object with valid flag, warnings, and errors
+ */
+export declare function validateCoolifyState(state: Record<string, unknown>): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
 /**
  * Formats timestamp to relative time.
  *

package/dist/utils/format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/utils/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,YAAY,CAAC;AAY/B;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,eAOlE;AAmBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAWnD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQjD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAY5D"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/utils/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,YAAY,CAAC;AAY/B;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,eAOlE;AAmBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAWnD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQjD;AAID;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG;IAC5C,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAqCA;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,CAqBtE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACpE,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAmFA;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAY5D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mks2508/coolify-mks-cli-mcp",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "MCP server and CLI for Coolify deployment management",
   "type": "module",
   "main": "./dist/index.js",
@@ -66,6 +66,7 @@
     "shiki": "^4.0.2"
   },
   "devDependencies": {
+    "@types/bun": "^1.3.14",
     "@types/node": "^22.10.5",
     "@types/prompts": "^2.4.9",
     "rolldown": "^1.0.0-beta.58",