@mks2508/coolify-mks-cli-mcp 0.6.3 → 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;
+    }
     if (appType === "public" || appType === "private-github-app" || appType === "private-deploy-key") {
-      if (options.githubRepoUrl) {
-        body.git_repository = options.githubRepoUrl.replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
-      }
       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 })
-      });
-      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 })
-          });
-          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) {
@@ -18681,33 +18718,18 @@ class CoolifyService {
     log.success(`Environment variables retrieved for ${appUuid}`);
     return ok(result.data || []);
   }
-  async setEnvironmentVariable(appUuid, key, value, _isBuildTime = false) {
-    log.info(`Setting environment variable ${key} for ${appUuid}`);
-    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 })
-      });
-      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 })
-      });
-      if (result.error) {
-        log.error(`Failed to create env var: ${result.error}`);
-        return err(new Error(result.error));
+  async setEnvironmentVariable(appUuid, key, value, isBuildTime = false) {
+    log.info(`Setting environment variable ${key} for ${appUuid} (buildtime: ${isBuildTime})`);
+    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);
@@ -18781,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;
@@ -18916,10 +18955,32 @@ 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)
+      body.health_check_path = options.healthCheckPath;
+    if (options.healthCheckPort)
+      body.health_check_port = String(options.healthCheckPort);
+    if (options.healthCheckMethod)
+      body.health_check_method = options.healthCheckMethod;
+    if (options.healthCheckInterval)
+      body.health_check_interval = options.healthCheckInterval;
+    if (options.healthCheckTimeout)
+      body.health_check_timeout = options.healthCheckTimeout;
+    if (options.healthCheckRetries)
+      body.health_check_retries = options.healthCheckRetries;
+    if (options.healthCheckStartPeriod)
+      body.health_check_start_period = options.healthCheckStartPeriod;
+    if (options.healthCheckReturnCode)
+      body.health_check_return_code = options.healthCheckReturnCode;
     const result = await this.request(`/applications/${appUuid}`, {
       method: "PATCH",
       body: JSON.stringify(body)
@@ -18972,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}`);
@@ -18981,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}`);
@@ -19243,6 +19317,133 @@ class CoolifyService {
     log.success(`Service deleted: ${uuid2}`);
     return ok({ success: true, message: "Service deleted" });
   }
+  async getInfrastructureTree() {
+    log.info("Building infrastructure tree");
+    const [projectsResult, appsResult, dbsResult, svcsResult, serversResult] = await Promise.all([
+      this.listProjects(),
+      this.listApplications(),
+      this.listDatabases(),
+      this.listServices(),
+      this.listServers()
+    ]);
+    if (isErr(projectsResult))
+      return err(projectsResult.error);
+    if (isErr(appsResult))
+      return err(appsResult.error);
+    if (isErr(serversResult))
+      return err(serversResult.error);
+    const projects = projectsResult.value;
+    const apps = appsResult.value;
+    const dbs = isErr(dbsResult) ? [] : dbsResult.value;
+    const svcs = isErr(svcsResult) ? [] : svcsResult.value;
+    const servers = serversResult.value;
+    const envResults = await Promise.allSettled(projects.map((p) => this.getProjectEnvironments(p.uuid)));
+    const envIdMap = new Map;
+    for (let i = 0;i < projects.length; i++) {
+      const envResult = envResults[i];
+      if (envResult.status === "fulfilled" && !isErr(envResult.value)) {
+        for (const env of envResult.value.value) {
+          envIdMap.set(env.id, {
+            projectUuid: projects[i].uuid,
+            envName: env.name,
+            envUuid: env.uuid
+          });
+        }
+      }
+    }
+    const projectNodes = projects.map((p) => ({
+      uuid: p.uuid,
+      name: p.name,
+      description: p.description,
+      environments: []
+    }));
+    const projectMap = new Map;
+    for (const node of projectNodes) {
+      projectMap.set(node.uuid, node);
+    }
+    const envNodeMap = new Map;
+    for (const [envId, info] of envIdMap) {
+      const project = projectMap.get(info.projectUuid);
+      if (!project)
+        continue;
+      let envNode = project.environments.find((e) => e.id === envId);
+      if (!envNode) {
+        envNode = {
+          id: envId,
+          uuid: info.envUuid,
+          name: info.envName,
+          resources: []
+        };
+        project.environments.push(envNode);
+      }
+      envNodeMap.set(envId, envNode);
+    }
+    for (const app of apps) {
+      const envNode = app.environment_id ? envNodeMap.get(app.environment_id) : undefined;
+      const resource = {
+        uuid: app.uuid,
+        name: app.name,
+        kind: "app",
+        status: app.status,
+        fqdn: app.fqdn
+      };
+      if (envNode) {
+        envNode.resources.push(resource);
+      }
+    }
+    for (const db of dbs) {
+      const envNode = db.environment_id ? envNodeMap.get(db.environment_id) : undefined;
+      const resource = {
+        uuid: db.uuid,
+        name: db.name,
+        kind: "database",
+        status: db.status,
+        dbType: db.type
+      };
+      if (envNode) {
+        envNode.resources.push(resource);
+      }
+    }
+    for (const svc of svcs) {
+      const envNode = svc.environment_id ? envNodeMap.get(svc.environment_id) : undefined;
+      const resource = {
+        uuid: svc.uuid,
+        name: svc.name,
+        kind: "service",
+        status: svc.status
+      };
+      if (envNode) {
+        envNode.resources.push(resource);
+      }
+    }
+    const populatedProjects = projectNodes.filter((p) => p.environments.some((e) => e.resources.length > 0));
+    const allStatuses = [
+      ...apps.map((a) => a.status),
+      ...dbs.map((d) => d.status),
+      ...svcs.map((s) => s.status)
+    ];
+    const counts = {
+      projects: populatedProjects.length,
+      apps: apps.length,
+      databases: dbs.length,
+      services: svcs.length,
+      healthy: allStatuses.filter((s) => s.includes("healthy")).length,
+      running: allStatuses.filter((s) => s.startsWith("running") && !s.includes("healthy")).length,
+      stopped: allStatuses.filter((s) => s.includes("exited")).length,
+      unhealthy: allStatuses.filter((s) => s.includes("unhealthy")).length
+    };
+    const server = servers[0] || { name: "Unknown" };
+    log.success(`Infrastructure tree built: ${counts.projects} projects, ${counts.apps} apps, ${counts.databases} dbs, ${counts.services} svcs`);
+    return ok({
+      server: {
+        name: server.name,
+        ip: server.ip,
+        uuid: server.uuid
+      },
+      projects: populatedProjects,
+      counts
+    });
+  }
   async startService(uuid2) {
     log.info(`Starting service ${uuid2}`);
     const result = await this.request(`/services/${uuid2}/start`, { method: "GET" });
@@ -19273,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`);
@@ -19504,6 +19769,17 @@ class CoolifyService {
     log.success(`Listed ${deployments.length} deployments for ${appUuid}`);
     return ok(deployments);
   }
+  async getApplication(appUuid) {
+    log.info(`Getting application details: ${appUuid}`);
+    const result = await this.request(`/applications/${appUuid}`);
+    if (result.error) {
+      return err(new Error(result.error));
+    }
+    if (!result.data) {
+      return err(new Error("Application not found"));
+    }
+    return ok(result.data);
+  }
   async resolveApplication(query) {
     log.info(`Resolving application: ${query}`);
     if (this.isLikelyUuid(query)) {
@@ -19784,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))
@@ -19802,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));
   }
@@ -19847,6 +20148,77 @@ class ApplicationsResource {
   async deleteEnv(uuid2, key) {
     return unwrap(await this.svc.deleteEnvironmentVariable(uuid2, key));
   }
+  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 = 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) {
+      return { added: [], updated: [], removed: [], skipped: 0 };
+    }
+    const currentVarsList = await this.envVars(uuid2);
+    const currentVars = new Map(currentVarsList.map((v) => [v.key, v.value]));
+    const toAdd = [];
+    const toUpdate = [];
+    const toRemove = [];
+    for (const [key, value] of localVars.entries()) {
+      const currentValue = currentVars.get(key);
+      if (!currentValue) {
+        toAdd.push({ key, value });
+      } else if (currentValue !== value) {
+        toUpdate.push({ key, value, oldValue: currentValue });
+      }
+    }
+    if (prune) {
+      for (const key of currentVars.keys()) {
+        if (!localVars.has(key)) {
+          toRemove.push(key);
+        }
+      }
+    }
+    if (!dryRun) {
+      for (const { key, value } of toAdd) {
+        await this.setEnv(uuid2, key, value, false);
+        onProgress?.({ type: "add", key, value });
+      }
+      for (const { key, value } of toUpdate) {
+        await this.setEnv(uuid2, key, value, false);
+        onProgress?.({ type: "update", key, value });
+      }
+      for (const key of toRemove) {
+        await this.deleteEnv(uuid2, key);
+        onProgress?.({ type: "remove", key });
+      }
+    } else {
+      for (const { key, value } of toAdd) {
+        onProgress?.({ type: "add", key, value });
+      }
+      for (const { key, value } of toUpdate) {
+        onProgress?.({ type: "update", key, value });
+      }
+      for (const key of toRemove) {
+        onProgress?.({ type: "remove", key });
+      }
+    }
+    return {
+      added: toAdd,
+      updated: toUpdate,
+      removed: toRemove,
+      skipped: currentVars.size - toUpdate.length - toRemove.length
+    };
+  }
+  parseEnvContent(content) {
+    return parseEnvContent(content);
+  }
 }
 
 class DatabasesResource {
@@ -19893,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 {
@@ -19931,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));
   }
 }
 
@@ -20265,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,