@mks2508/coolify-mks-cli-mcp 0.4.3 → 0.6.0

package/dist/cli/index.js

@@ -17,6 +17,16 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../../node_modules/.bun/commander@12.1.0/node_modules/commander/lib/error.js
@@ -1858,6 +1868,27 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// ../../../node_modules/.bun/@mks2508+no-throw@0.1.0/node_modules/@mks2508/no-throw/dist/index.mjs
+function ok(value) {
+  return {
+    ok: true,
+    value
+  };
+}
+function err(error) {
+  return {
+    ok: false,
+    error
+  };
+}
+function isOk(result) {
+  return result.ok;
+}
+function isErr(result) {
+  return !result.ok;
+}
+var init_dist = () => {};
+
 // ../../../node_modules/.bun/cli-spinners@2.9.2/node_modules/cli-spinners/spinners.json
 var require_spinners = __commonJS((exports, module) => {
   module.exports = {
@@ -5188,6 +5219,206 @@ var require_table = __commonJS((exports, module) => {
   module.exports = Table;
 });
 
+// src/trace.ts
+class OperationTracer {
+  operation;
+  steps = [];
+  startTime;
+  stepStart;
+  onStep;
+  constructor(operation, onStep) {
+    this.operation = operation;
+    this.startTime = Date.now();
+    this.stepStart = this.startTime;
+    this.onStep = onStep;
+  }
+  step(step, detail) {
+    const now = Date.now();
+    const traceStep = {
+      ts: new Date(now).toISOString(),
+      step,
+      durationMs: now - this.stepStart,
+      detail
+    };
+    this.steps.push(traceStep);
+    this.stepStart = now;
+    this.onStep?.(step, detail);
+    if (process.stderr.isTTY) {
+      const prefix = `\x1B[90m[${this.operation}]\x1B[0m`;
+      const elapsed = `\x1B[33m${traceStep.durationMs}ms\x1B[0m`;
+      const detailStr = detail ? ` \x1B[90m(${detail})\x1B[0m` : "";
+      process.stderr.write(`${prefix} ${step} ${elapsed}${detailStr}
+`);
+    }
+  }
+  finish(success, error) {
+    return {
+      operation: this.operation,
+      steps: this.steps,
+      totalMs: Date.now() - this.startTime,
+      success,
+      error
+    };
+  }
+}
+
+// src/network.ts
+var exports_network = {};
+__export(exports_network, {
+  inspectNetwork: () => inspectNetwork,
+  analyzeDeployFailure: () => analyzeDeployFailure
+});
+async function safeExec(svc, uuid, command) {
+  const result = await svc.executeCommand(uuid, command);
+  if (isErr(result))
+    return "";
+  return result.value.response || result.value.message || "";
+}
+async function inspectNetwork(svc, appUuid, servicesToTest = []) {
+  const tracer = new OperationTracer("network:inspect");
+  try {
+    tracer.step("Fetching /etc/hosts");
+    const hostsRaw = await safeExec(svc, appUuid, "cat /etc/hosts 2>/dev/null");
+    const hosts = hostsRaw.split(`
+`).filter((l) => l.trim() && !l.startsWith("#"));
+    tracer.step("Checking network interfaces");
+    const ifRaw = await safeExec(svc, appUuid, "ip addr 2>/dev/null || ifconfig 2>/dev/null || cat /proc/net/if_inet6 2>/dev/null || echo 'no network tools'");
+    const interfaces = ifRaw.split(`
+`).filter((l) => l.includes("inet") || l.includes("scope"));
+    tracer.step("Extracting network env vars");
+    const envRaw = await safeExec(svc, appUuid, "env 2>/dev/null | grep -iE '(HOST|PORT|URL|DATABASE|REDIS|MONGO|POSTGRES|MYSQL|DB_|COOLIFY)' | sort");
+    const networkEnv = {};
+    for (const line of envRaw.split(`
+`).filter(Boolean)) {
+      const [key, ...rest] = line.split("=");
+      if (key)
+        networkEnv[key] = rest.join("=");
+    }
+    tracer.step("Testing DNS resolution");
+    const dnsTargets = [
+      ...servicesToTest,
+      ...Object.values(networkEnv).filter((v) => !v.includes("/") && !v.includes(":")).filter((v) => /^[a-z][a-z0-9-]*$/i.test(v))
+    ];
+    const uniqueTargets = [...new Set(dnsTargets)].slice(0, 10);
+    const dns = [];
+    for (const hostname of uniqueTargets) {
+      const nslookup = await safeExec(svc, appUuid, `getent hosts ${hostname} 2>/dev/null || nslookup ${hostname} 2>/dev/null || echo 'FAIL'`);
+      const resolved = !nslookup.includes("FAIL") && nslookup.trim().length > 0;
+      const ip = resolved ? nslookup.split(/\s+/)[0] : undefined;
+      dns.push({ hostname, resolved, ip });
+    }
+    tracer.step("Testing service connectivity", `${uniqueTargets.length} targets`);
+    const connectivity = [];
+    for (const target of servicesToTest) {
+      const start = Date.now();
+      const curlResult = await safeExec(svc, appUuid, `timeout 3 sh -c "echo > /dev/tcp/${target}/80 2>/dev/null && echo OK || curl -sf --max-time 2 http://${target}/ >/dev/null 2>&1 && echo OK || echo FAIL"`);
+      connectivity.push({
+        target,
+        reachable: curlResult.includes("OK"),
+        responseTime: Date.now() - start
+      });
+    }
+    const trace = tracer.finish(true);
+    return ok({ hosts, dns, networkEnv, connectivity, interfaces, trace });
+  } catch (error) {
+    const trace = tracer.finish(false, error instanceof Error ? error.message : String(error));
+    return err(new Error(`Network inspection failed: ${trace.error}`));
+  }
+}
+async function analyzeDeployFailure(svc, deploymentUuid) {
+  const tracer = new OperationTracer("deploy:analyze");
+  try {
+    tracer.step("Fetching deployment details");
+    const deployResult = await svc.getDeploymentLogs(deploymentUuid);
+    if (isErr(deployResult)) {
+      return err(deployResult.error);
+    }
+    const { status, logs: rawLogs } = deployResult.value;
+    tracer.step("Extracting error lines", `${rawLogs.length} chars`);
+    const lines = rawLogs.split(`
+`);
+    const errors = lines.filter((l) => /error|ERR!|failed|FAIL|fatal|panic|exception/i.test(l) && !/no error|success/i.test(l));
+    tracer.step("Categorizing error");
+    let matchedPattern = ERROR_PATTERNS.find((p) => p.pattern.test(rawLogs));
+    if (!matchedPattern) {
+      matchedPattern = {
+        pattern: /./,
+        category: "unknown",
+        summary: "Unknown build failure",
+        suggestion: "Check the full build logs with `build-logs <deployment-uuid>` for details."
+      };
+    }
+    const trace = tracer.finish(true);
+    return ok({
+      deploymentUuid,
+      status,
+      rawLogs,
+      errors: errors.slice(0, 20),
+      category: matchedPattern.category,
+      summary: matchedPattern.summary,
+      suggestion: matchedPattern.suggestion,
+      trace
+    });
+  } catch (error) {
+    const trace = tracer.finish(false, error instanceof Error ? error.message : String(error));
+    return err(new Error(`Deploy analysis failed: ${trace.error}`));
+  }
+}
+var ERROR_PATTERNS;
+var init_network = __esm(() => {
+  init_dist();
+  ERROR_PATTERNS = [
+    {
+      pattern: /npm ERR!|yarn error|pnpm ERR/i,
+      category: "install_error",
+      summary: "Package installation failed",
+      suggestion: "Check package.json for invalid dependencies. Try deleting lock file and rebuilding."
+    },
+    {
+      pattern: /COPY failed|COPY --from.*not found|no such file/i,
+      category: "docker_error",
+      summary: "Dockerfile COPY failed — file not found",
+      suggestion: "Check Dockerfile paths and base_directory. Ensure source files exist in build context."
+    },
+    {
+      pattern: /error TS\d+|TypeError|SyntaxError|ReferenceError/i,
+      category: "build_error",
+      summary: "TypeScript/JavaScript compilation error",
+      suggestion: "Fix the type errors locally before deploying. Run `bun run typecheck`."
+    },
+    {
+      pattern: /ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|getaddrinfo/i,
+      category: "network_error",
+      summary: "Network connectivity issue during build",
+      suggestion: "Server may have DNS issues or firewall blocking outbound connections. Check server network."
+    },
+    {
+      pattern: /OOMKilled|out of memory|Cannot allocate memory/i,
+      category: "build_error",
+      summary: "Out of memory during build",
+      suggestion: "Server ran out of RAM. Use a build server or increase server memory."
+    },
+    {
+      pattern: /context deadline exceeded|timed out/i,
+      category: "timeout",
+      summary: "Operation timed out",
+      suggestion: "Build took too long. Check if server is overloaded or network is slow."
+    },
+    {
+      pattern: /permission denied|EACCES/i,
+      category: "docker_error",
+      summary: "Permission denied",
+      suggestion: "Check file permissions in Dockerfile. Ensure non-root user has access to needed paths."
+    },
+    {
+      pattern: /exec.*not found|command not found/i,
+      category: "build_error",
+      summary: "Command not found during build",
+      suggestion: "A required binary is missing in the Docker image. Add it to the Dockerfile or use a different base image."
+    }
+  ];
+});
+
 // ../../../node_modules/.bun/commander@12.1.0/node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -5693,25 +5924,8 @@ var chalk = createChalk();
 var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
-// ../../../node_modules/.bun/@mks2508+no-throw@0.1.0/node_modules/@mks2508/no-throw/dist/index.mjs
-function ok(value) {
-  return {
-    ok: true,
-    value
-  };
-}
-function err(error) {
-  return {
-    ok: false,
-    error
-  };
-}
-function isOk(result) {
-  return result.ok;
-}
-function isErr(result) {
-  return !result.ok;
-}
+// src/cli/commands/create.ts
+init_dist();
 
 // ../../../node_modules/.bun/ora@8.2.0/node_modules/ora/index.js
 import process9 from "node:process";
@@ -6523,6 +6737,9 @@ function ora(options) {
   return new Ora(options);
 }
 
+// src/coolify/index.ts
+init_dist();
+
 // ../../../node_modules/.bun/@mks2508+better-logger@4.0.0/node_modules/@mks2508/better-logger/dist/chunks/environment-COWvu6Wz.js
 function isMinifiedFile(filename) {
   const minifiedPatterns = [
@@ -11131,6 +11348,7 @@ var stylePresets = {
 };
 
 // src/coolify/config.ts
+init_dist();
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
@@ -11201,7 +11419,11 @@ class CoolifyService {
   async request(endpoint, options = {}) {
     const startTime = Date.now();
     if (!this.baseUrl || !this.token) {
-      return { error: "Coolify not configured", status: 0, durationMs: Date.now() - startTime };
+      return {
+        error: "Coolify not configured",
+        status: 0,
+        durationMs: Date.now() - startTime
+      };
     }
     try {
       const baseUrl = this.baseUrl.replace(/\/+$/, "");
@@ -11222,7 +11444,11 @@ class CoolifyService {
         data = text ? JSON.parse(text) : undefined;
       } catch {
         if (!response.ok) {
-          return { error: text || `HTTP ${response.status}`, status: response.status, durationMs };
+          return {
+            error: text || `HTTP ${response.status}`,
+            status: response.status,
+            durationMs
+          };
         }
       }
       if (!response.ok) {
@@ -11258,7 +11484,7 @@ class CoolifyService {
       params.set("force", "true");
     const endpoint = `/deploy${params.toString() ? `?${params.toString()}` : ""}`;
     const result = await this.request(endpoint, {
-      method: "POST"
+      method: "GET"
     });
     if (result.error) {
       log.error(`Deployment failed: ${result.error}`);
@@ -11291,7 +11517,9 @@ class CoolifyService {
       "private-deploy-key": "/applications/private-deploy-key",
       dockerfile: "/applications/dockerfile",
       "docker-image": "/applications/docker-image",
-      "docker-compose": "/applications/docker-compose"
+      "docker-compose": "/applications/docker-compose",
+      dockerimage: "/applications/dockerimage",
+      dockercompose: "/applications/dockercompose"
     };
     const endpoint = endpointMap[appType] || "/applications/public";
     const body = {
@@ -11355,7 +11583,9 @@ class CoolifyService {
         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" });
+          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 })
@@ -11387,7 +11617,7 @@ class CoolifyService {
     log.success(`Environment variables retrieved for ${appUuid}`);
     return ok(result.data || []);
   }
-  async setEnvironmentVariable(appUuid, key, value, isBuildTime = false) {
+  async setEnvironmentVariable(appUuid, key, value, _isBuildTime = false) {
     log.info(`Setting environment variable ${key} for ${appUuid}`);
     const existingVars = await this.getEnvironmentVariables(appUuid);
     if (isErr(existingVars)) {
@@ -11446,8 +11676,17 @@ class CoolifyService {
     }
     return ok(result.data?.status || "unknown");
   }
-  async listServers() {
-    const result = await this.request("/servers");
+  async listServers(page, perPage) {
+    let endpoint = "/servers";
+    const params = new URLSearchParams;
+    if (page)
+      params.set("page", page.toString());
+    if (perPage)
+      params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
+    const result = await this.request(endpoint);
     if (result.error) {
       return err(new Error(result.error));
     }
@@ -11463,14 +11702,32 @@ class CoolifyService {
     log.success(`Server details retrieved: ${serverUuid}`);
     return ok(result.data);
   }
-  async listGithubApps() {
-    const result = await this.request("/github-apps");
+  async listGithubApps(page, perPage) {
+    let endpoint = "/github-apps";
+    const params = new URLSearchParams;
+    if (page)
+      params.set("page", page.toString());
+    if (perPage)
+      params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
+    const result = await this.request(endpoint);
     if (result.error)
       return err(new Error(result.error));
     return ok(result.data || []);
   }
-  async listProjects() {
-    const result = await this.request("/projects");
+  async listProjects(page, perPage) {
+    let endpoint = "/projects";
+    const params = new URLSearchParams;
+    if (page)
+      params.set("page", page.toString());
+    if (perPage)
+      params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
+    const result = await this.request(endpoint);
     if (result.error) {
       return err(new Error(result.error));
     }
@@ -11499,8 +11756,17 @@ class CoolifyService {
     log.success(`Environments retrieved for project ${projectUuid}`);
     return ok(result.data?.environments || []);
   }
-  async listTeams() {
-    const result = await this.request("/teams");
+  async listTeams(page, perPage) {
+    let endpoint = "/teams";
+    const params = new URLSearchParams;
+    if (page)
+      params.set("page", page.toString());
+    if (perPage)
+      params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
+    const result = await this.request(endpoint);
     if (result.error) {
       return err(new Error(result.error));
     }
@@ -11513,7 +11779,7 @@ class CoolifyService {
     }
     return ok(result.data?.destinations || []);
   }
-  async listApplications(teamId, projectId) {
+  async listApplications(teamId, projectId, page, perPage) {
     log.info("Listing applications");
     let endpoint = "/applications";
     const params = new URLSearchParams;
@@ -11521,6 +11787,10 @@ class CoolifyService {
       params.set("team_id", teamId);
     if (projectId)
       params.set("project_id", projectId);
+    if (page)
+      params.set("page", page.toString());
+    if (perPage)
+      params.set("per_page", perPage.toString());
     if (params.toString()) {
       endpoint += `?${params.toString()}`;
     }
@@ -11532,9 +11802,20 @@ class CoolifyService {
     log.success(`Listed ${result.data?.length || 0} applications`);
     return ok(result.data || []);
   }
-  async deleteApplication(appUuid) {
+  async deleteApplication(appUuid, options) {
     log.info(`Deleting application ${appUuid}`);
-    const result = await this.request(`/applications/${appUuid}`, {
+    const params = new URLSearchParams;
+    if (options?.deleteConfigurations)
+      params.set("delete_configurations", "true");
+    if (options?.deleteVolumes)
+      params.set("delete_volumes", "true");
+    if (options?.dockerCleanup)
+      params.set("docker_cleanup", "true");
+    if (options?.deleteConnectedNetworks)
+      params.set("delete_connected_networks", "true");
+    const queryString = params.toString();
+    const endpoint = `/applications/${appUuid}${queryString ? `?${queryString}` : ""}`;
+    const result = await this.request(endpoint, {
       method: "DELETE"
     });
     if (result.error) {
@@ -11592,7 +11873,9 @@ class CoolifyService {
     if (options.follow)
       params.set("follow", "true");
     if (options.tail)
-      params.set("tail", options.tail.toString());
+      params.set("lines", options.tail.toString());
+    if (options.serviceName)
+      params.set("service_name", options.serviceName);
     const endpoint = `/applications/${appUuid}/logs${params.toString() ? `?${params.toString()}` : ""}`;
     const result = await this.request(endpoint);
     if (result.error) {
@@ -11608,9 +11891,35 @@ class CoolifyService {
       timestamp: new Date().toISOString()
     });
   }
+  async executeCommand(appUuid, command) {
+    log.info(`Executing command on application ${appUuid}`);
+    const result = await this.request(`/applications/${appUuid}/execute-command`, {
+      method: "POST",
+      body: JSON.stringify({ command })
+    });
+    if (result.error) {
+      log.error(`Failed to execute command: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    log.success(`Command executed on ${appUuid}`);
+    return ok(result.data || { message: "Command executed" });
+  }
+  async bulkUpdateEnvironmentVariables(appUuid, envVars) {
+    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)
+    });
+    if (result.error) {
+      log.error(`Failed to bulk update env vars: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    log.success(`Bulk updated ${envVars.length} env vars for ${appUuid}`);
+    return ok(result.data || { message: "Environment variables updated" });
+  }
   async getApplicationDeploymentHistory(appUuid) {
     log.info(`Getting deployment history for ${appUuid}`);
-    const result = await this.request(`/applications/${appUuid}/deployments`);
+    const result = await this.request(`/deployments/applications/${appUuid}`);
     if (result.error) {
       log.error(`Failed to get deployment history: ${result.error}`);
       return err(new Error(result.error));
@@ -11618,10 +11927,17 @@ class CoolifyService {
     log.success(`Deployment history retrieved for ${appUuid}`);
     return ok(result.data?.deployments || []);
   }
-  async startApplication(appUuid) {
+  async startApplication(appUuid, options) {
     log.info(`Starting application ${appUuid}`);
-    const result = await this.request(`/applications/${appUuid}/start`, {
-      method: "POST"
+    const params = new URLSearchParams;
+    if (options?.force)
+      params.set("force", "true");
+    if (options?.instantDeploy)
+      params.set("instant_deploy", "true");
+    const queryString = params.toString();
+    const endpoint = `/applications/${appUuid}/start${queryString ? `?${queryString}` : ""}`;
+    const result = await this.request(endpoint, {
+      method: "GET"
     });
     if (result.error) {
       log.error(`Failed to start application: ${result.error}`);
@@ -11632,9 +11948,7 @@ class CoolifyService {
   }
   async stopApplication(appUuid) {
     log.info(`Stopping application ${appUuid}`);
-    const result = await this.request(`/applications/${appUuid}/stop`, {
-      method: "POST"
-    });
+    const result = await this.request(`/applications/${appUuid}/stop`, { method: "GET" });
     if (result.error) {
       log.error(`Failed to stop application: ${result.error}`);
       return err(new Error(result.error));
@@ -11644,9 +11958,7 @@ class CoolifyService {
   }
   async restartApplication(appUuid) {
     log.info(`Restarting application ${appUuid}`);
-    const result = await this.request(`/applications/${appUuid}/restart`, {
-      method: "POST"
-    });
+    const result = await this.request(`/applications/${appUuid}/restart`, { method: "GET" });
     if (result.error) {
       log.error(`Failed to restart application: ${result.error}`);
       return err(new Error(result.error));
@@ -11654,281 +11966,1529 @@ class CoolifyService {
     log.success(`Application restarted: ${appUuid}`);
     return ok(result.data);
   }
-  async listDeployments() {
-    log.info("Listing active deployments");
-    const result = await this.request("/deployments");
-    if (result.error) {
-      log.error(`Failed to list deployments: ${result.error}`);
-      return err(new Error(result.error));
+  async getVersion() {
+    log.info("Getting Coolify version");
+    if (!this.baseUrl || !this.token) {
+      return err(new Error("Coolify not configured"));
     }
-    log.success(`Listed ${result.data?.length || 0} active deployments`);
-    return ok(result.data || []);
-  }
-  async getDeployment(deploymentUuid) {
-    log.info(`Getting deployment details for ${deploymentUuid}`);
-    const result = await this.request(`/deployments/${deploymentUuid}`);
-    if (result.error) {
-      log.error(`Failed to get deployment: ${result.error}`);
-      return err(new Error(result.error));
+    try {
+      const baseUrl = this.baseUrl.replace(/\/+$/, "");
+      const url = `${baseUrl}/api/v1/version`;
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${this.token}`
+        }
+      });
+      if (!response.ok) {
+        return err(new Error(`HTTP ${response.status}: ${response.statusText}`));
+      }
+      const version = (await response.text()).trim();
+      log.success(`Coolify version: ${version}`);
+      return ok({ version });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return err(new Error(message));
     }
-    log.success(`Deployment details retrieved: ${deploymentUuid}`);
-    return ok(result.data);
   }
-  async getApplicationDeployments(appUuid, skip = 0, take = 10) {
-    log.info(`Getting deployments for application ${appUuid}`);
+  async listDatabases(page, perPage) {
+    log.info("Listing databases");
+    let endpoint = "/databases";
     const params = new URLSearchParams;
-    if (skip > 0)
-      params.set("skip", skip.toString());
-    if (take !== 10)
-      params.set("take", take.toString());
-    const endpoint = `/applications/${appUuid}/deployments${params.toString() ? `?${params.toString()}` : ""}`;
+    if (page)
+      params.set("page", page.toString());
+    if (perPage)
+      params.set("per_page", perPage.toString());
+    if (params.toString())
+      endpoint += `?${params.toString()}`;
     const result = await this.request(endpoint);
-    if (result.error) {
-      log.error(`Failed to get application deployments: ${result.error}`);
+    if (result.error)
       return err(new Error(result.error));
-    }
-    const deployments = result.data?.deployments || [];
-    log.success(`Retrieved ${deployments.length} deployments for ${appUuid}`);
-    return ok(deployments);
+    log.success(`Listed ${result.data?.length || 0} databases`);
+    return ok(result.data || []);
   }
-}
-var instance = null;
-function getCoolifyService() {
-  if (!instance) {
-    instance = new CoolifyService;
+  async getDatabase(uuid) {
+    log.info(`Getting database ${uuid}`);
+    const result = await this.request(`/databases/${uuid}`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data);
   }
-  return instance;
-}
-
-// src/cli/commands/create.ts
-async function createCommand2(options) {
-  const spinner = ora("Initializing Coolify connection...").start();
-  try {
-    const coolify = getCoolifyService();
-    const initResult = await coolify.init();
-    if (isErr(initResult)) {
-      spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
-      return;
-    }
-    let environmentUuid = options.environment;
-    if (!environmentUuid) {
-      spinner.text = "Fetching project environments...";
-      const envResult = await coolify.getProjectEnvironments(options.project);
-      if (isOk(envResult) && envResult.value.length > 0) {
-        environmentUuid = envResult.value[0].uuid;
-        const envName = envResult.value[0].name;
-        spinner.info(source_default.cyan(`Using environment: ${envName} (${environmentUuid.slice(0, 8)}...)`));
-      } else {
-        spinner.fail(source_default.red("No environments found for project. Please specify --environment <uuid>"));
-        return;
-      }
-    }
-    if (!environmentUuid) {
-      spinner.fail(source_default.red("Environment UUID is required"));
-      return;
-    }
-    spinner.text = "Creating application...";
-    const result = await coolify.createApplication({
-      name: options.name,
-      description: options.description,
-      projectUuid: options.project,
-      environmentUuid,
-      serverUuid: options.server,
-      type: options.type || "public",
-      githubRepoUrl: options.repo,
-      branch: options.branch || "main",
-      buildPack: options.buildPack || "dockerfile",
-      portsExposes: options.ports || "3000",
-      dockerImage: options.dockerImage,
-      dockerCompose: options.dockerCompose,
-      dockerComposeLocation: options.dockerComposeLocation,
-      dockerfileLocation: options.dockerfileLocation,
-      baseDirectory: options.baseDirectory
-    }, (percent, message) => {
-      spinner.text = `${source_default.bold(`[${percent}%]`)} ${message}`;
+  async createDatabase(dbType, data) {
+    log.info(`Creating ${dbType} database`);
+    const result = await this.request(`/databases/${dbType}`, {
+      method: "POST",
+      body: JSON.stringify(data)
     });
-    if (isOk(result)) {
-      spinner.succeed(source_default.green(`Application created! UUID: ${source_default.cyan(result.value.uuid?.slice(0, 8))}`));
-      console.log(`  Full UUID: ${source_default.cyan(result.value.uuid)}`);
-      console.log(`  Name: ${source_default.cyan(options.name)}`);
-      console.log(`  Type: ${source_default.cyan(options.type || "public")}`);
-      console.log(`  Next steps:`);
-      console.log(`    1. Set environment variables: ${source_default.yellow("coolify-mcp env " + result.value.uuid?.slice(0, 8))}`);
-      console.log(`    2. Deploy application: ${source_default.yellow("coolify-mcp deploy " + result.value.uuid?.slice(0, 8))}`);
-    } else {
-      spinner.fail(source_default.red(`Creation failed: ${result.error.message}`));
-    }
-  } catch (error) {
-    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Database created: ${result.data?.uuid}`);
+    return ok(result.data);
   }
-}
-
-// src/cli/commands/deploy.ts
-async function deployCommand(uuid, options) {
-  const spinner = ora("Initializing Coolify connection...").start();
-  try {
-    const coolify = getCoolifyService();
-    const initResult = await coolify.init();
-    if (isErr(initResult)) {
-      spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
-      return;
-    }
-    spinner.text = "Triggering deployment...";
-    const result = await coolify.deploy({
-      uuid,
-      force: options.force,
-      tag: options.tag
-    }, (percent, message) => {
-      spinner.text = `${source_default.bold(`[${percent}%]`)} ${message}`;
+  async updateDatabase(uuid, data) {
+    log.info(`Updating database ${uuid}`);
+    const result = await this.request(`/databases/${uuid}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
     });
-    if (isOk(result)) {
-      spinner.succeed(source_default.green(`Deployment triggered! UUID: ${source_default.cyan(result.value.deploymentUuid?.slice(0, 8))}`));
-      console.log(`  Resource UUID: ${source_default.cyan(result.value.resourceUuid?.slice(0, 8))}`);
-    } else {
-      spinner.fail(source_default.red(`Deployment failed: ${result.error.message}`));
-    }
-  } catch (error) {
-    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
-  }
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Database updated: ${uuid}`);
+    return ok(result.data);
+  }
+  async deleteDatabase(uuid, options) {
+    log.info(`Deleting database ${uuid}`);
+    const params = new URLSearchParams;
+    if (options?.deleteConfigurations)
+      params.set("delete_configurations", "true");
+    if (options?.deleteVolumes)
+      params.set("delete_volumes", "true");
+    if (options?.dockerCleanup)
+      params.set("docker_cleanup", "true");
+    if (options?.deleteConnectedNetworks)
+      params.set("delete_connected_networks", "true");
+    const queryString = params.toString();
+    const endpoint = `/databases/${uuid}${queryString ? `?${queryString}` : ""}`;
+    const result = await this.request(endpoint, {
+      method: "DELETE"
+    });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Database deleted: ${uuid}`);
+    return ok({ success: true, message: "Database deleted" });
+  }
+  async startDatabase(uuid) {
+    log.info(`Starting database ${uuid}`);
+    const result = await this.request(`/databases/${uuid}/start`, { method: "GET" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Database started: ${uuid}`);
+    return ok(result.data || { message: "Database started" });
+  }
+  async stopDatabase(uuid) {
+    log.info(`Stopping database ${uuid}`);
+    const result = await this.request(`/databases/${uuid}/stop`, { method: "GET" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Database stopped: ${uuid}`);
+    return ok(result.data || { message: "Database stopped" });
+  }
+  async restartDatabase(uuid) {
+    log.info(`Restarting database ${uuid}`);
+    const result = await this.request(`/databases/${uuid}/restart`, { method: "GET" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Database restarted: ${uuid}`);
+    return ok(result.data || { message: "Database restarted" });
+  }
+  async listDatabaseBackups(databaseUuid) {
+    log.info(`Listing backups for database ${databaseUuid}`);
+    const result = await this.request(`/databases/${databaseUuid}/backups`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || []);
+  }
+  async getDatabaseBackup(databaseUuid, backupUuid) {
+    const result = await this.request(`/databases/${databaseUuid}/backups/${backupUuid}`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data);
+  }
+  async createDatabaseBackup(databaseUuid, data) {
+    log.info(`Creating backup for database ${databaseUuid}`);
+    const result = await this.request(`/databases/${databaseUuid}/backups`, { method: "POST", body: JSON.stringify(data) });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success("Database backup created");
+    return ok(result.data);
+  }
+  async updateDatabaseBackup(databaseUuid, backupUuid, data) {
+    const result = await this.request(`/databases/${databaseUuid}/backups/${backupUuid}`, { method: "PATCH", body: JSON.stringify(data) });
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || { message: "Backup updated" });
+  }
+  async deleteDatabaseBackup(databaseUuid, backupUuid) {
+    const result = await this.request(`/databases/${databaseUuid}/backups/${backupUuid}`, { method: "DELETE" });
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || { message: "Backup deleted" });
+  }
+  async listServices(page, perPage) {
+    log.info("Listing services");
+    let endpoint = "/services";
+    const params = new URLSearchParams;
+    if (page)
+      params.set("page", page.toString());
+    if (perPage)
+      params.set("per_page", perPage.toString());
+    if (params.toString())
+      endpoint += `?${params.toString()}`;
+    const result = await this.request(endpoint);
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Listed ${result.data?.length || 0} services`);
+    return ok(result.data || []);
+  }
+  async getService(uuid) {
+    log.info(`Getting service ${uuid}`);
+    const result = await this.request(`/services/${uuid}`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data);
+  }
+  async createService(data) {
+    log.info("Creating service");
+    const result = await this.request("/services", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Service created: ${result.data?.uuid}`);
+    return ok(result.data);
+  }
+  async updateService(uuid, data) {
+    log.info(`Updating service ${uuid}`);
+    const result = await this.request(`/services/${uuid}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Service updated: ${uuid}`);
+    return ok(result.data);
+  }
+  async deleteService(uuid, options) {
+    log.info(`Deleting service ${uuid}`);
+    const params = new URLSearchParams;
+    if (options?.deleteConfigurations)
+      params.set("delete_configurations", "true");
+    if (options?.deleteVolumes)
+      params.set("delete_volumes", "true");
+    if (options?.dockerCleanup)
+      params.set("docker_cleanup", "true");
+    if (options?.deleteConnectedNetworks)
+      params.set("delete_connected_networks", "true");
+    const queryString = params.toString();
+    const endpoint = `/services/${uuid}${queryString ? `?${queryString}` : ""}`;
+    const result = await this.request(endpoint, {
+      method: "DELETE"
+    });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Service deleted: ${uuid}`);
+    return ok({ success: true, message: "Service deleted" });
+  }
+  async startService(uuid) {
+    log.info(`Starting service ${uuid}`);
+    const result = await this.request(`/services/${uuid}/start`, { method: "GET" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Service started: ${uuid}`);
+    return ok(result.data || { message: "Service started" });
+  }
+  async stopService(uuid) {
+    log.info(`Stopping service ${uuid}`);
+    const result = await this.request(`/services/${uuid}/stop`, { method: "GET" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Service stopped: ${uuid}`);
+    return ok(result.data || { message: "Service stopped" });
+  }
+  async restartService(uuid) {
+    log.info(`Restarting service ${uuid}`);
+    const result = await this.request(`/services/${uuid}/restart`, { method: "GET" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Service restarted: ${uuid}`);
+    return ok(result.data || { message: "Service restarted" });
+  }
+  async listServiceEnvVars(uuid) {
+    const result = await this.request(`/services/${uuid}/envs`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || []);
+  }
+  async createServiceEnvVar(uuid, data) {
+    const result = await this.request(`/services/${uuid}/envs`, { method: "POST", body: JSON.stringify(data) });
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data);
+  }
+  async getServerResources(serverUuid) {
+    log.info(`Getting resources for server ${serverUuid}`);
+    const result = await this.request(`/servers/${serverUuid}/resources`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || []);
+  }
+  async getServerDomains(serverUuid) {
+    log.info(`Getting domains for server ${serverUuid}`);
+    const result = await this.request(`/servers/${serverUuid}/domains`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || []);
+  }
+  async validateServer(serverUuid) {
+    log.info(`Validating server ${serverUuid}`);
+    const result = await this.request(`/servers/${serverUuid}/validate`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || { message: "Server validated" });
+  }
+  async createServer(data) {
+    log.info("Creating server");
+    const result = await this.request("/servers", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Server created: ${result.data?.uuid}`);
+    return ok(result.data);
+  }
+  async deleteServer(serverUuid) {
+    log.info(`Deleting server ${serverUuid}`);
+    const result = await this.request(`/servers/${serverUuid}`, { method: "DELETE" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Server deleted: ${serverUuid}`);
+    return ok(result.data || { message: "Server deleted" });
+  }
+  async updateProject(uuid, data) {
+    log.info(`Updating project ${uuid}`);
+    const result = await this.request(`/projects/${uuid}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Project updated: ${uuid}`);
+    return ok(result.data);
+  }
+  async deleteProject(uuid) {
+    log.info(`Deleting project ${uuid}`);
+    const result = await this.request(`/projects/${uuid}`, { method: "DELETE" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Project deleted: ${uuid}`);
+    return ok(result.data || { message: "Project deleted" });
+  }
+  async createProjectEnvironment(projectUuid, data) {
+    log.info(`Creating environment in project ${projectUuid}`);
+    const result = await this.request(`/projects/${projectUuid}/environments`, { method: "POST", body: JSON.stringify(data) });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success("Environment created");
+    return ok(result.data);
+  }
+  async getCurrentTeam() {
+    log.info("Getting current team");
+    const result = await this.request("/teams/current");
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data);
+  }
+  async getTeam(id) {
+    log.info(`Getting team ${id}`);
+    const result = await this.request(`/teams/${id}`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data);
+  }
+  async getTeamMembers(id) {
+    log.info(`Getting members for team ${id}`);
+    const result = await this.request(`/teams/${id}/members`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || []);
+  }
+  async cancelDeployment(deploymentUuid) {
+    log.info(`Cancelling deployment ${deploymentUuid}`);
+    const result = await this.request(`/deployments/${deploymentUuid}/cancel`, { method: "POST" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Deployment cancelled: ${deploymentUuid}`);
+    return ok(result.data || { message: "Deployment cancelled" });
+  }
+  async listPrivateKeys() {
+    log.info("Listing private keys");
+    const result = await this.request("/security/keys");
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || []);
+  }
+  async getPrivateKey(uuid) {
+    const result = await this.request(`/security/keys/${uuid}`);
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data);
+  }
+  async createPrivateKey(data) {
+    log.info("Creating private key");
+    const result = await this.request("/security/keys", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Private key created: ${result.data?.uuid}`);
+    return ok(result.data);
+  }
+  async updatePrivateKey(uuid, data) {
+    const result = await this.request(`/security/keys/${uuid}`, { method: "PATCH", body: JSON.stringify(data) });
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data);
+  }
+  async deletePrivateKey(uuid) {
+    log.info(`Deleting private key ${uuid}`);
+    const result = await this.request(`/security/keys/${uuid}`, { method: "DELETE" });
+    if (result.error)
+      return err(new Error(result.error));
+    log.success(`Private key deleted: ${uuid}`);
+    return ok(result.data || { message: "Private key deleted" });
+  }
+  async createGitHubApp(data) {
+    log.info("Creating GitHub App");
+    const result = await this.request("/github-apps", { method: "POST", body: JSON.stringify(data) });
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data);
+  }
+  async updateGitHubApp(id, data) {
+    const result = await this.request(`/github-apps/${id}`, { method: "PATCH", body: JSON.stringify(data) });
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || { message: "GitHub App updated" });
+  }
+  async deleteGitHubApp(id) {
+    log.info(`Deleting GitHub App ${id}`);
+    const result = await this.request(`/github-apps/${id}`, { method: "DELETE" });
+    if (result.error)
+      return err(new Error(result.error));
+    return ok(result.data || { message: "GitHub App deleted" });
+  }
+  async listDeployments(page, perPage) {
+    log.info("Listing active deployments");
+    let endpoint = "/deployments";
+    const params = new URLSearchParams;
+    if (page)
+      params.set("page", page.toString());
+    if (perPage)
+      params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
+    const result = await this.request(endpoint);
+    if (result.error) {
+      log.error(`Failed to list deployments: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    log.success(`Listed ${result.data?.length || 0} active deployments`);
+    return ok(result.data || []);
+  }
+  async getDeployment(deploymentUuid) {
+    log.info(`Getting deployment details for ${deploymentUuid}`);
+    const result = await this.request(`/deployments/${deploymentUuid}`);
+    if (result.error) {
+      log.error(`Failed to get deployment: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    log.success(`Deployment details retrieved: ${deploymentUuid}`);
+    return ok(result.data);
+  }
+  async getDeploymentLogs(deploymentUuid) {
+    log.info(`Getting deployment logs for ${deploymentUuid}`);
+    const result = await this.request(`/deployments/${deploymentUuid}`);
+    if (result.error) {
+      log.error(`Failed to get deployment logs: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    log.success(`Deployment logs retrieved: ${deploymentUuid}`);
+    return ok({
+      status: result.data?.status || "unknown",
+      logs: result.data?.logs || "",
+      deployment_uuid: result.data?.deployment_uuid || deploymentUuid
+    });
+  }
+  async getApplicationDeployments(appUuid, skip = 0, take = 10) {
+    log.info(`Getting deployments for application ${appUuid}`);
+    const params = new URLSearchParams;
+    if (skip > 0)
+      params.set("skip", skip.toString());
+    if (take !== 10)
+      params.set("take", take.toString());
+    const endpoint = `/applications/${appUuid}/deployments${params.toString() ? `?${params.toString()}` : ""}`;
+    const result = await this.request(endpoint);
+    if (result.error) {
+      log.error(`Failed to get application deployments: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    const deployments = result.data?.deployments || [];
+    log.success(`Retrieved ${deployments.length} deployments for ${appUuid}`);
+    return ok(deployments);
+  }
+  async listApplicationDeployments(appUuid) {
+    log.info(`Listing deployments for application ${appUuid}`);
+    const result = await this.request(`/deployments/applications/${appUuid}`);
+    if (result.error) {
+      log.error(`Failed to list application deployments: ${result.error}`);
+      return err(new Error(result.error));
+    }
+    const deployments = result.data?.deployments || [];
+    log.success(`Listed ${deployments.length} deployments for ${appUuid}`);
+    return ok(deployments);
+  }
+  async resolveApplication(query) {
+    log.info(`Resolving application: ${query}`);
+    if (this.isLikelyUuid(query)) {
+      const apps2 = await this.listApplications();
+      if (isErr(apps2))
+        return err(apps2.error);
+      const match = apps2.value.find((a) => a.uuid === query);
+      if (match)
+        return ok(match);
+    }
+    const apps = await this.listApplications();
+    if (isErr(apps))
+      return err(apps.error);
+    const lowerQuery = query.toLowerCase();
+    const matches = apps.value.filter((a) => a.name?.toLowerCase() === lowerQuery || a.fqdn?.toLowerCase().includes(lowerQuery) || a.uuid.startsWith(query));
+    if (matches.length === 1)
+      return ok(matches[0]);
+    if (matches.length === 0) {
+      return err(new Error(`No application found matching "${query}". Use 'list' to see available applications.`));
+    }
+    const names = matches.map((a) => `  - ${a.name} (${a.uuid})`).join(`
+`);
+    return err(new Error(`Multiple applications match "${query}":
+${names}
+Please use the full UUID.`));
+  }
+  async resolveServer(query) {
+    log.info(`Resolving server: ${query}`);
+    const servers = await this.listServers();
+    if (isErr(servers))
+      return err(servers.error);
+    const lowerQuery = query.toLowerCase();
+    const match = servers.value.find((s) => s.uuid === query || s.name?.toLowerCase() === lowerQuery || s.ip === query || s.uuid.startsWith(query));
+    if (match)
+      return ok(match);
+    return err(new Error(`No server found matching "${query}". Use 'servers' to see available servers.`));
+  }
+  isLikelyUuid(query) {
+    if (/^[a-z0-9]{20,}$/i.test(query))
+      return true;
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(query))
+      return true;
+    return false;
+  }
+  async diagnoseApplication(query) {
+    log.info(`Diagnosing application: ${query}`);
+    const appResult = await this.resolveApplication(query);
+    if (isErr(appResult))
+      return err(appResult.error);
+    const app = appResult.value;
+    const issues = [];
+    const [deploymentsResult, envResult, logsResult] = await Promise.all([
+      this.getApplicationDeploymentHistory(app.uuid),
+      this.getEnvironmentVariables(app.uuid),
+      this.getApplicationLogs(app.uuid, { tail: 20 })
+    ]);
+    const deployments = isErr(deploymentsResult) ? [] : deploymentsResult.value;
+    const envVarCount = isErr(envResult) ? 0 : envResult.value.length;
+    const recentLogs = isErr(logsResult) ? [] : logsResult.value.logs;
+    if (app.status?.includes("stopped")) {
+      issues.push("Application is stopped");
+    }
+    if (!app.fqdn) {
+      issues.push("No domain configured");
+    }
+    if (envVarCount === 0) {
+      issues.push("No environment variables set");
+    }
+    const recentDeploys = deployments.slice(-5);
+    const failedDeploys = recentDeploys.filter((d) => d.status?.includes("failed"));
+    if (failedDeploys.length > 0) {
+      issues.push(`${failedDeploys.length} of last ${recentDeploys.length} deployments failed`);
+    }
+    log.success(`Diagnosis complete for ${app.name}`);
+    return ok({
+      application: app,
+      recentDeployments: recentDeploys,
+      envVarCount,
+      recentLogs,
+      issues
+    });
+  }
+  async diagnoseServer(query) {
+    log.info(`Diagnosing server: ${query}`);
+    const serverResult = await this.resolveServer(query);
+    if (isErr(serverResult))
+      return err(serverResult.error);
+    const server = serverResult.value;
+    const issues = [];
+    const [resourcesResult, domainsResult] = await Promise.all([
+      this.getServerResources(server.uuid),
+      this.getServerDomains(server.uuid)
+    ]);
+    const resources = isErr(resourcesResult) ? [] : resourcesResult.value;
+    const domains = isErr(domainsResult) ? [] : domainsResult.value;
+    if (!server.is_reachable) {
+      issues.push("Server is not reachable");
+    }
+    if (!server.is_usable) {
+      issues.push("Server is not usable");
+    }
+    if (resources.length === 0) {
+      issues.push("No resources deployed on this server");
+    }
+    log.success(`Server diagnosis complete for ${server.name}`);
+    return ok({ server, resources, domains, issues });
+  }
+  async findInfrastructureIssues() {
+    log.info("Scanning infrastructure for issues");
+    const [serversR, appsR, dbsR, svcsR] = await Promise.all([
+      this.listServers(),
+      this.listApplications(),
+      this.listDatabases(),
+      this.listServices()
+    ]);
+    const servers = isErr(serversR) ? [] : serversR.value;
+    const apps = isErr(appsR) ? [] : appsR.value;
+    const dbs = isErr(dbsR) ? [] : dbsR.value;
+    const svcs = isErr(svcsR) ? [] : svcsR.value;
+    const issues = [];
+    for (const server of servers) {
+      if (!server.is_reachable) {
+        issues.push({
+          type: "server",
+          resource: server.name,
+          uuid: server.uuid,
+          message: "Server unreachable"
+        });
+      }
+    }
+    for (const app of apps) {
+      if (app.status?.includes("stopped")) {
+        issues.push({
+          type: "application",
+          resource: app.name,
+          uuid: app.uuid,
+          message: "Application stopped"
+        });
+      }
+      if (app.status?.includes("failed") || app.status?.includes("error")) {
+        issues.push({
+          type: "application",
+          resource: app.name,
+          uuid: app.uuid,
+          message: `Status: ${app.status}`
+        });
+      }
+    }
+    for (const db of dbs) {
+      if (db.status?.includes("stopped") || db.status?.includes("exited")) {
+        issues.push({
+          type: "database",
+          resource: db.name,
+          uuid: db.uuid,
+          message: `Database stopped: ${db.status}`
+        });
+      }
+    }
+    for (const svc of svcs) {
+      if (svc.status?.includes("stopped") || svc.status?.includes("exited")) {
+        issues.push({
+          type: "service",
+          resource: svc.name,
+          uuid: svc.uuid,
+          message: `Service stopped: ${svc.status}`
+        });
+      }
+    }
+    log.success(`Infrastructure scan complete: ${issues.length} issue(s) found`);
+    return ok({
+      totalServers: servers.length,
+      totalApps: apps.length,
+      totalDatabases: dbs.length,
+      totalServices: svcs.length,
+      issues
+    });
+  }
+  async restartProjectApps(projectUuid) {
+    log.info(`Restarting all apps in project ${projectUuid}`);
+    const appsResult = await this.listApplications(undefined, projectUuid);
+    if (isErr(appsResult))
+      return err(appsResult.error);
+    const apps = appsResult.value;
+    const failed = [];
+    let succeeded = 0;
+    for (const app of apps) {
+      const result = await this.restartApplication(app.uuid);
+      if (isErr(result)) {
+        failed.push(`${app.name} (${app.uuid}): ${result.error.message}`);
+      } else {
+        succeeded++;
+      }
+    }
+    log.success(`Restarted ${succeeded}/${apps.length} apps in project`);
+    return ok({ total: apps.length, succeeded, failed });
+  }
+  async redeployProjectApps(projectUuid, force = false) {
+    log.info(`Redeploying all apps in project ${projectUuid}`);
+    const appsResult = await this.listApplications(undefined, projectUuid);
+    if (isErr(appsResult))
+      return err(appsResult.error);
+    const apps = appsResult.value;
+    const failed = [];
+    let succeeded = 0;
+    for (const app of apps) {
+      const result = await this.deploy({ uuid: app.uuid, force });
+      if (isErr(result)) {
+        failed.push(`${app.name} (${app.uuid}): ${result.error.message}`);
+      } else {
+        succeeded++;
+      }
+    }
+    log.success(`Redeployed ${succeeded}/${apps.length} apps in project`);
+    return ok({ total: apps.length, succeeded, failed });
+  }
+  async stopAllApps() {
+    log.info("Stopping all applications");
+    const appsResult = await this.listApplications();
+    if (isErr(appsResult))
+      return err(appsResult.error);
+    const running = appsResult.value.filter((a) => !a.status?.includes("stopped"));
+    const failed = [];
+    let succeeded = 0;
+    for (const app of running) {
+      const result = await this.stopApplication(app.uuid);
+      if (isErr(result)) {
+        failed.push(`${app.name} (${app.uuid}): ${result.error.message}`);
+      } else {
+        succeeded++;
+      }
+    }
+    log.success(`Stopped ${succeeded}/${running.length} apps`);
+    return ok({ total: running.length, succeeded, failed });
+  }
+  async listApplicationSummaries() {
+    const result = await this.listApplications();
+    if (isErr(result))
+      return err(result.error);
+    return ok(result.value.map((a) => ({
+      uuid: a.uuid,
+      name: a.name,
+      status: a.status,
+      fqdn: a.fqdn || null
+    })));
+  }
+  async listServerSummaries() {
+    const result = await this.listServers();
+    if (isErr(result))
+      return err(result.error);
+    return ok(result.value.map((s) => ({
+      uuid: s.uuid,
+      name: s.name,
+      ip: s.ip || "",
+      is_reachable: s.is_reachable || false
+    })));
+  }
+  async listDatabaseSummaries() {
+    const result = await this.listDatabases();
+    if (isErr(result))
+      return err(result.error);
+    return ok(result.value.map((d) => ({
+      uuid: d.uuid,
+      name: d.name,
+      type: d.type,
+      status: d.status
+    })));
+  }
+  async listServiceSummaries() {
+    const result = await this.listServices();
+    if (isErr(result))
+      return err(result.error);
+    return ok(result.value.map((s) => ({
+      uuid: s.uuid,
+      name: s.name,
+      type: s.type,
+      status: s.status
+    })));
+  }
+}
+var instance = null;
+function getCoolifyService() {
+  if (!instance) {
+    instance = new CoolifyService;
+  }
+  return instance;
+}
+
+// src/cli/commands/create.ts
+async function createCommand2(options) {
+  const spinner = ora("Initializing Coolify connection...").start();
+  try {
+    const coolify = getCoolifyService();
+    const initResult = await coolify.init();
+    if (isErr(initResult)) {
+      spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
+      return;
+    }
+    let environmentUuid = options.environment;
+    if (!environmentUuid) {
+      spinner.text = "Fetching project environments...";
+      const envResult = await coolify.getProjectEnvironments(options.project);
+      if (isOk(envResult) && envResult.value.length > 0) {
+        environmentUuid = envResult.value[0].uuid;
+        const envName = envResult.value[0].name;
+        spinner.info(source_default.cyan(`Using environment: ${envName} (${environmentUuid})`));
+      } else {
+        spinner.fail(source_default.red("No environments found for project. Please specify --environment <uuid>"));
+        return;
+      }
+    }
+    if (!environmentUuid) {
+      spinner.fail(source_default.red("Environment UUID is required"));
+      return;
+    }
+    spinner.text = "Creating application...";
+    const result = await coolify.createApplication({
+      name: options.name,
+      description: options.description,
+      projectUuid: options.project,
+      environmentUuid,
+      serverUuid: options.server,
+      type: options.type || "public",
+      githubRepoUrl: options.repo,
+      branch: options.branch || "main",
+      buildPack: options.buildPack || "dockerfile",
+      portsExposes: options.ports || "3000",
+      dockerImage: options.dockerImage,
+      dockerCompose: options.dockerCompose,
+      dockerComposeLocation: options.dockerComposeLocation,
+      dockerfileLocation: options.dockerfileLocation,
+      baseDirectory: options.baseDirectory
+    }, (percent, message) => {
+      spinner.text = `${source_default.bold(`[${percent}%]`)} ${message}`;
+    });
+    if (isOk(result)) {
+      spinner.succeed(source_default.green(`Application created! UUID: ${source_default.cyan(result.value.uuid)}`));
+      console.log(`  Name: ${source_default.cyan(options.name)}`);
+      console.log(`  Type: ${source_default.cyan(options.type || "public")}`);
+      console.log(`  Next steps:`);
+      console.log(`    1. Set environment variables: ${source_default.yellow("coolify-mcp env " + result.value.uuid)}`);
+      console.log(`    2. Deploy application: ${source_default.yellow("coolify-mcp deploy " + result.value.uuid)}`);
+    } else {
+      spinner.fail(source_default.red(`Creation failed: ${result.error.message}`));
+    }
+  } catch (error) {
+    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+
+// src/cli/commands/deploy.ts
+init_dist();
+
+// src/cli/coolify-state.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var STATE_FILE = ".coolify.json";
+function loadCoolifyState() {
+  const statePath = join2(process.cwd(), STATE_FILE);
+  if (!existsSync2(statePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(statePath, "utf-8");
+    const state = JSON.parse(content);
+    if (!state.appUuid) {
+      return null;
+    }
+    return state;
+  } catch {
+    return null;
+  }
+}
+function resolveUuid(uuid, field = "appUuid") {
+  if (uuid)
+    return uuid;
+  const state = loadCoolifyState();
+  if (!state)
+    return null;
+  const value = state[field];
+  return typeof value === "string" ? value : null;
+}
+
+// src/cli/commands/deploy.ts
+async function deployCommand(uuid, options) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found in current directory"));
+    return;
+  }
+  uuid = resolvedUuid;
+  const spinner = ora("Initializing Coolify connection...").start();
+  try {
+    const coolify = getCoolifyService();
+    const initResult = await coolify.init();
+    if (isErr(initResult)) {
+      spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
+      return;
+    }
+    spinner.text = "Triggering deployment...";
+    const result = await coolify.deploy({
+      uuid,
+      force: options.force,
+      tag: options.tag
+    }, (percent, message) => {
+      spinner.text = `${source_default.bold(`[${percent}%]`)} ${message}`;
+    });
+    if (isOk(result)) {
+      spinner.succeed(source_default.green(`Deployment triggered! UUID: ${source_default.cyan(result.value.deploymentUuid)}`));
+      console.log(`  Resource UUID: ${source_default.cyan(result.value.resourceUuid)}`);
+    } else {
+      spinner.fail(source_default.red(`Deployment failed: ${result.error.message}`));
+    }
+  } catch (error) {
+    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+
+// src/cli/commands/list.ts
+init_dist();
+var import_cli_table32 = __toESM(require_table(), 1);
+
+// src/utils/format.ts
+var import_cli_table3 = __toESM(require_table(), 1);
+function getTerminalWidth2() {
+  return process.stdout.columns || 80;
+}
+function createTable(headers, colWidths) {
+  const columns = getTerminalWidth2();
+  return new import_cli_table3.default({
+    head: headers.map((h) => source_default.cyan(h)),
+    colWidths: colWidths || calculateColumnWidths(columns, headers.length)
+  });
+}
+function calculateColumnWidths(totalWidth, numColumns) {
+  const padding = 4;
+  const availableWidth = totalWidth - padding * numColumns;
+  const colWidth = Math.floor(availableWidth / numColumns);
+  return Array(numColumns).fill(colWidth);
+}
+function formatStatus(status) {
+  const statusMap = {
+    running: source_default.green("● Running"),
+    "running:unknown": source_default.green("● Running"),
+    stopped: source_default.red("○ Stopped"),
+    restarting: source_default.yellow("◐ Restarting"),
+    error: source_default.red("✗ Error"),
+    deploying: source_default.yellow("◐ Deploying")
+  };
+  return statusMap[status] || status;
+}
+
+// src/cli/commands/list.ts
+async function listCommand(options) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.listApplications(options.team, options.project);
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  const apps = result.value;
+  if (apps.length === 0) {
+    console.log(source_default.yellow("No applications found"));
+    return;
+  }
+  const table = new import_cli_table32.default({
+    head: [
+      source_default.cyan("UUID"),
+      source_default.cyan("Name"),
+      source_default.cyan("Status"),
+      source_default.cyan("Server")
+    ]
+  });
+  for (const app of apps) {
+    table.push([
+      app.uuid,
+      app.name,
+      formatStatus(app.status),
+      app.destination?.server?.name || "N/A"
+    ]);
+  }
+  console.log(table.toString());
+  console.log(source_default.gray(`Total: ${apps.length} application(s)`));
+}
+
+// src/cli/commands/logs.ts
+init_dist();
+async function logsCommand(uuid, options) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
+    return;
+  }
+  uuid = resolvedUuid;
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.getApplicationLogs(uuid, {
+    tail: options.lines || 50
+  });
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  const logs = result.value;
+  if (logs.logs.length === 0) {
+    console.log(source_default.yellow("No logs available"));
+    return;
+  }
+  console.log(source_default.gray(`Application logs (${logs.logs.length} lines):
+`));
+  for (const line of logs.logs) {
+    console.log(line);
+  }
+  if (options.follow) {
+    console.log(source_default.yellow(`
+Follow mode not yet implemented`));
+  }
+}
+
+// src/cli/commands/servers.ts
+init_dist();
+async function serversCommand(_options = {}) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.listServers();
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  const servers = result.value;
+  if (servers.length === 0) {
+    console.log(source_default.yellow("No servers found"));
+    return;
+  }
+  const table = createTable(["UUID", "Name", "IP", "Status"], [28, 25, 20, 15]);
+  for (const server of servers) {
+    const statusColor = server.is_usable ? source_default.green : source_default.red;
+    table.push([
+      server.uuid,
+      server.name,
+      server.ip || "N/A",
+      statusColor(server.is_usable ? "● Usable" : "○ Unusable")
+    ]);
+  }
+  console.log(table.toString());
+  console.log(source_default.gray(`Total: ${servers.length} server(s)`));
+}
+
+// src/cli/commands/projects.ts
+init_dist();
+var import_cli_table33 = __toESM(require_table(), 1);
+async function projectsCommand(options = {}) {
+  const spinner = ora("Connecting to Coolify...").start();
+  try {
+    const coolify = getCoolifyService();
+    const initResult = await coolify.init();
+    if (isErr(initResult)) {
+      spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
+      return;
+    }
+    if (options.create) {
+      spinner.text = `Creating project "${options.create}"...`;
+      const createResult = await coolify.createProject(options.create, options.description);
+      if (isOk(createResult)) {
+        spinner.succeed(source_default.green(`Project created: ${source_default.cyan(createResult.value.uuid)}`));
+        console.log(`  Name: ${source_default.cyan(options.create)}`);
+        console.log(`  UUID: ${source_default.cyan(createResult.value.uuid)}`);
+      } else {
+        spinner.fail(source_default.red(`Failed to create project: ${createResult.error.message}`));
+      }
+      return;
+    }
+    spinner.text = "Fetching projects...";
+    const result = await coolify.listProjects();
+    if (isOk(result)) {
+      spinner.succeed(source_default.green("Projects retrieved"));
+      const projects = result.value;
+      if (projects.length === 0) {
+        console.log(source_default.yellow("No projects found"));
+        return;
+      }
+      const table = new import_cli_table33.default({
+        head: [
+          source_default.cyan("UUID"),
+          source_default.cyan("Name"),
+          source_default.cyan("Description")
+        ]
+      });
+      for (const project of projects) {
+        table.push([project.uuid, project.name, project.description || "-"]);
+      }
+      console.log(table.toString());
+      console.log(source_default.gray(`Total: ${projects.length} project(s)`));
+    } else {
+      spinner.fail(source_default.red(`Failed to fetch projects: ${result.error.message}`));
+    }
+  } catch (error) {
+    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+
+// src/cli/commands/environments.ts
+init_dist();
+var import_cli_table34 = __toESM(require_table(), 1);
+async function environmentsCommand(projectUuid, _options = {}) {
+  const spinner = ora("Connecting to Coolify...").start();
+  try {
+    const coolify = getCoolifyService();
+    const initResult = await coolify.init();
+    if (isErr(initResult)) {
+      spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
+      return;
+    }
+    spinner.text = `Fetching environments for project ${projectUuid}...`;
+    const result = await coolify.getProjectEnvironments(projectUuid);
+    if (isOk(result)) {
+      spinner.succeed(source_default.green("Environments retrieved"));
+      const environments = result.value;
+      if (environments.length === 0) {
+        console.log(source_default.yellow("No environments found for this project"));
+        return;
+      }
+      const table = new import_cli_table34.default({
+        head: [
+          source_default.cyan("UUID"),
+          source_default.cyan("Name"),
+          source_default.cyan("Description")
+        ]
+      });
+      for (const env2 of environments) {
+        table.push([env2.uuid, env2.name, env2.description || "-"]);
+      }
+      console.log(table.toString());
+      console.log(source_default.gray(`Total: ${environments.length} environment(s)`));
+    } else {
+      spinner.fail(source_default.red(`Failed to fetch environments: ${result.error.message}`));
+    }
+  } catch (error) {
+    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+
+// src/cli/commands/config.ts
+init_dist();
+import { existsSync as existsSync3 } from "node:fs";
+async function configCommand(action, args) {
+  if (action === "set") {
+    if (!args.key || !args.value) {
+      console.error(source_default.red('Error: key and value are required for "set" command'));
+      console.log(source_default.gray("Usage: coolify-mcp config set <key> <value>"));
+      console.log(source_default.gray("Keys: url, token"));
+      return;
+    }
+    const result = await loadConfig();
+    if (isOk(result)) {
+      const config = result.value;
+      if (args.key === "url") {
+        config.url = args.value;
+      } else if (args.key === "token") {
+        config.token = args.value;
+      } else {
+        console.error(source_default.red(`Error: Unknown key "${args.key}"`));
+        return;
+      }
+      const saveResult = await saveConfig(config);
+      if (isOk(saveResult)) {
+        console.log(source_default.green(`Config updated: ${args.key} = ${args.value}`));
+      } else {
+        console.error(source_default.red(`Error: ${saveResult.error.message}`));
+      }
+    }
+  } else if (action === "get") {
+    const result = await loadConfig();
+    if (isOk(result)) {
+      const config = result.value;
+      console.log(source_default.cyan("Current configuration:"));
+      console.log(`  URL: ${source_default.gray(config.url || "(not set)")}`);
+      console.log(`  Token: ${source_default.gray(config.token ? "(set)" : "(not set)")}`);
+    } else {
+      console.error(source_default.red(`Error: ${result.error.message}`));
+    }
+  } else if (action === "path") {
+    console.log(source_default.cyan("Config file:"));
+    console.log(`  ${CONFIG_FILE}`);
+    if (existsSync3(CONFIG_FILE)) {
+      console.log(source_default.gray("  Status: File exists"));
+    } else {
+      console.log(source_default.yellow("  Status: File does not exist"));
+    }
+  } else {
+    console.log(source_default.cyan("Coolify MCP Configuration"));
+    console.log();
+    console.log(source_default.gray("Commands:"));
+    console.log("  coolify-mcp config set <key> <value>  Set a config value");
+    console.log("  coolify-mcp config get                 Show current config");
+    console.log("  coolify-mcp config path                Show config file path");
+    console.log();
+    console.log(source_default.gray("Keys:"));
+    console.log("  url    - Coolify instance URL");
+    console.log("  token  - Coolify API token");
+    console.log();
+    console.log(source_default.gray("Environment variables:"));
+    console.log("  COOLIFY_URL     - Coolify instance URL");
+    console.log("  COOLIFY_TOKEN   - Coolify API token");
+  }
 }
 
-// src/cli/commands/list.ts
-var import_cli_table32 = __toESM(require_table(), 1);
-
-// src/utils/format.ts
-var import_cli_table3 = __toESM(require_table(), 1);
-function getTerminalWidth2() {
-  return process.stdout.columns || 80;
-}
-function createTable(headers, colWidths) {
-  const columns = getTerminalWidth2();
-  return new import_cli_table3.default({
-    head: headers.map((h) => source_default.cyan(h)),
-    colWidths: colWidths || calculateColumnWidths(columns, headers.length)
-  });
+// src/cli/commands/env.ts
+init_dist();
+async function envCommand(uuid, options = {}) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
+    return;
+  }
+  uuid = resolvedUuid;
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  if (options.set) {
+    const [key, ...valueParts] = options.set.split("=");
+    const value = valueParts.join("=");
+    if (!key || value === undefined) {
+      console.error(source_default.red("Error: Invalid format. Use --set KEY=VALUE"));
+      return;
+    }
+    const result2 = await coolify.setEnvironmentVariable(uuid, key, value, options.buildtime ?? false);
+    if (isErr(result2)) {
+      console.error(source_default.red(`Error: ${result2.error.message}`));
+      return;
+    }
+    console.log(source_default.green(`✓ Set ${source_default.bold(key)} for ${uuid}`));
+    return;
+  }
+  if (options.delete) {
+    const result2 = await coolify.deleteEnvironmentVariable(uuid, options.delete);
+    if (isErr(result2)) {
+      console.error(source_default.red(`Error: ${result2.error.message}`));
+      return;
+    }
+    console.log(source_default.green(`✓ Deleted ${source_default.bold(options.delete)} from ${uuid}`));
+    return;
+  }
+  const result = await coolify.getEnvironmentVariables(uuid);
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  const envVars = result.value;
+  if (envVars.length === 0) {
+    console.log(source_default.yellow("No environment variables found"));
+    return;
+  }
+  console.log(source_default.cyan(`Environment variables (${envVars.length}):
+`));
+  const runtimeVars = envVars.filter((ev) => ev.is_runtime);
+  const buildtimeVars = envVars.filter((ev) => ev.is_buildtime);
+  if (runtimeVars.length > 0) {
+    console.log(source_default.yellow.bold("Runtime:"));
+    for (const ev of runtimeVars) {
+      const required = ev.is_required ? source_default.red(" *") : "";
+      console.log(`  ${source_default.green(ev.key)}${required} = ${source_default.gray(ev.value)}`);
+    }
+    console.log();
+  }
+  if (buildtimeVars.length > 0) {
+    console.log(source_default.blue.bold("Buildtime:"));
+    for (const ev of buildtimeVars) {
+      console.log(`  ${source_default.green(ev.key)} = ${source_default.gray(ev.value)}`);
+    }
+  }
 }
-function calculateColumnWidths(totalWidth, numColumns) {
-  const padding = 4;
-  const availableWidth = totalWidth - padding * numColumns;
-  const colWidth = Math.floor(availableWidth / numColumns);
-  return Array(numColumns).fill(colWidth);
+
+// src/cli/commands/update.ts
+init_dist();
+async function updateCommand(options) {
+  const uuid = resolveUuid(options.uuid);
+  if (!uuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
+    return;
+  }
+  options.uuid = uuid;
+  console.log(source_default.cyan(`Updating application ${source_default.bold(uuid)}...`));
+  const service = getCoolifyService();
+  const initResult = await service.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red("Failed to initialize Coolify service"));
+    console.error(source_default.gray(initResult.error.message));
+    process.exit(1);
+  }
+  const updateOptions = {};
+  if (options.name)
+    updateOptions.name = options.name;
+  if (options.description)
+    updateOptions.description = options.description;
+  if (options.buildPack)
+    updateOptions.buildPack = options.buildPack;
+  if (options.gitBranch)
+    updateOptions.gitBranch = options.gitBranch;
+  if (options.ports)
+    updateOptions.portsExposes = options.ports;
+  if (options.installCommand)
+    updateOptions.installCommand = options.installCommand;
+  if (options.buildCommand)
+    updateOptions.buildCommand = options.buildCommand;
+  if (options.startCommand)
+    updateOptions.startCommand = options.startCommand;
+  if (options.dockerfileLocation)
+    updateOptions.dockerfileLocation = options.dockerfileLocation;
+  if (options.baseDirectory)
+    updateOptions.baseDirectory = options.baseDirectory;
+  if (options.domains)
+    updateOptions.domains = options.domains;
+  if (options.autoDeploy !== undefined)
+    updateOptions.isAutoDeployEnabled = options.autoDeploy;
+  if (options.forceHttps)
+    updateOptions.isForceHttpsEnabled = true;
+  if (Object.keys(updateOptions).length === 0) {
+    console.warn(source_default.yellow("No update options provided. Use --help to see available options."));
+    process.exit(0);
+  }
+  const result = await service.updateApplication(options.uuid, updateOptions);
+  if (isErr(result)) {
+    console.error(source_default.red("Failed to update application"));
+    console.error(source_default.gray(result.error.message));
+    process.exit(1);
+  }
+  console.log(source_default.green("Application updated successfully"));
+  console.log(source_default.gray(`UUID: ${result.value.uuid}`));
+  console.log(source_default.gray(`Name: ${result.value.name}`));
+  if (result.value.description) {
+    console.log(source_default.gray(`Description: ${result.value.description}`));
+  }
 }
-function formatStatus(status) {
-  const statusMap = {
-    running: source_default.green("● Running"),
-    "running:unknown": source_default.green("● Running"),
-    stopped: source_default.red("○ Stopped"),
-    restarting: source_default.yellow("◐ Restarting"),
-    error: source_default.red("✗ Error"),
-    deploying: source_default.yellow("◐ Deploying")
-  };
-  return statusMap[status] || status;
+
+// src/cli/commands/delete.ts
+init_dist();
+async function deleteCommand(uuid, options = {}) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
+    return;
+  }
+  uuid = resolvedUuid;
+  const service = getCoolifyService();
+  const initResult = await service.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red("Failed to initialize Coolify service"));
+    console.error(source_default.gray(initResult.error.message));
+    process.exit(1);
+  }
+  if (!options.force && !options.yes) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(source_default.yellow(`Are you sure you want to delete application ${source_default.bold(uuid)}? (yes/no): `), (ans) => {
+        rl.close();
+        resolve(ans.toLowerCase());
+      });
+    });
+    if (answer !== "yes" && answer !== "y") {
+      console.log(source_default.gray("Operation cancelled"));
+      process.exit(0);
+    }
+  }
+  console.log(source_default.cyan(`Deleting application ${source_default.bold(uuid)}...`));
+  const result = await service.deleteApplication(uuid);
+  if (isErr(result)) {
+    console.error(source_default.red("Failed to delete application"));
+    console.error(source_default.gray(result.error.message));
+    process.exit(1);
+  }
+  console.log(source_default.green("Application deleted successfully"));
+  if (result.value.message) {
+    console.log(source_default.gray(result.value.message));
+  }
 }
 
-// src/cli/commands/list.ts
-async function listCommand(options) {
+// src/cli/commands/destinations.ts
+init_dist();
+var import_cli_table35 = __toESM(require_table(), 1);
+async function destinationsCommand(serverUuid) {
   const coolify = getCoolifyService();
   const initResult = await coolify.init();
   if (isErr(initResult)) {
     console.error(source_default.red(`Error: ${initResult.error.message}`));
     return;
   }
-  const result = await coolify.listApplications(options.team, options.project);
+  const result = await coolify.getServerDestinations(serverUuid);
   if (isErr(result)) {
     console.error(source_default.red(`Error: ${result.error.message}`));
     return;
   }
-  const apps = result.value;
-  if (apps.length === 0) {
-    console.log(source_default.yellow("No applications found"));
-    return;
-  }
-  const table = new import_cli_table32.default({
-    head: [
-      source_default.cyan("UUID"),
-      source_default.cyan("Name"),
-      source_default.cyan("Status"),
-      source_default.cyan("Server")
-    ],
-    ...options.full ? { colWidths: [36, 30, 20, 10] } : {}
-  });
-  for (const app of apps) {
-    table.push([
-      options.full ? app.uuid : app.uuid.slice(0, 8),
-      app.name,
-      formatStatus(app.status),
-      app.destination?.server?.name || "N/A"
-    ]);
+  const destinations = result.value;
+  if (destinations.length === 0) {
+    console.log(source_default.yellow("No destinations found"));
+    return;
+  }
+  const table = new import_cli_table35.default({
+    head: [source_default.cyan("UUID"), source_default.cyan("Name"), source_default.cyan("Network")]
+  });
+  for (const dest of destinations) {
+    table.push([dest.uuid, dest.name, dest.network || "N/A"]);
   }
   console.log(table.toString());
-  console.log(source_default.gray(`Total: ${apps.length} application(s)`));
+  console.log(source_default.gray(`Total: ${destinations.length} destination(s)`));
 }
 
-// src/cli/commands/logs.ts
-async function logsCommand(uuid, options) {
+// src/cli/commands/show.ts
+init_dist();
+async function showCommand(uuid) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
+    return;
+  }
+  uuid = resolvedUuid;
   const coolify = getCoolifyService();
   const initResult = await coolify.init();
   if (isErr(initResult)) {
     console.error(source_default.red(`Error: ${initResult.error.message}`));
     return;
   }
-  const result = await coolify.getApplicationLogs(uuid, { tail: options.lines || 50 });
+  const result = await coolify.listApplications();
   if (isErr(result)) {
     console.error(source_default.red(`Error: ${result.error.message}`));
     return;
   }
-  const logs = result.value;
-  if (logs.logs.length === 0) {
-    console.log(source_default.yellow("No logs available"));
+  const apps = result.value;
+  const app = apps.find((a) => a.uuid === uuid || a.uuid.startsWith(uuid));
+  if (!app) {
+    console.error(source_default.red(`Application not found: ${uuid}`));
     return;
   }
-  console.log(source_default.gray(`Application logs (${logs.logs.length} lines):
-`));
-  for (const line of logs.logs) {
-    console.log(line);
-  }
-  if (options.follow) {
-    console.log(source_default.yellow(`
-Follow mode not yet implemented`));
+  console.log(source_default.cyan("Application Details:"));
+  console.log("");
+  console.log(source_default.gray("UUID:       ") + source_default.white(app.uuid));
+  console.log(source_default.gray("Name:       ") + source_default.white(app.name));
+  console.log(source_default.gray("Status:     ") + source_default.white(app.status));
+  console.log(source_default.gray("Description:") + source_default.white(app.description || "N/A"));
+  console.log(source_default.gray("Repository: ") + source_default.white(app.git_repository || "N/A"));
+  console.log(source_default.gray("Branch:     ") + source_default.white(app.git_branch || "N/A"));
+  console.log(source_default.gray("Build Pack: ") + source_default.white(app.build_pack || "N/A"));
+  console.log(source_default.gray("Ports:      ") + source_default.white(app.ports_exposes || "N/A"));
+  console.log(source_default.gray("FQDN:       ") + source_default.white(app.fqdn || "N/A"));
+  console.log(source_default.gray("Dockerfile: ") + source_default.white(app.dockerfile_location || "N/A"));
+  console.log(source_default.gray("Base Dir:   ") + source_default.white(app.base_directory || "N/A"));
+  console.log("");
+  console.log(source_default.cyan("Destination:"));
+  if (app.destination) {
+    console.log(source_default.gray("  UUID:  ") + source_default.white(app.destination.uuid));
+    console.log(source_default.gray("  Name:  ") + source_default.white(app.destination.name));
+    if (app.destination.server) {
+      console.log(source_default.gray("  Server:") + source_default.white(` ${app.destination.server.name} (${app.destination.server.ip})`));
+    }
+  } else {
+    console.log(source_default.yellow("  No destination configured"));
   }
+  console.log("");
+  console.log(source_default.cyan("Commands:"));
+  if (app.install_command)
+    console.log(source_default.gray("  Install: ") + source_default.white(app.install_command));
+  if (app.build_command)
+    console.log(source_default.gray("  Build:   ") + source_default.white(app.build_command));
+  if (app.start_command)
+    console.log(source_default.gray("  Start:   ") + source_default.white(app.start_command));
 }
 
-// src/cli/commands/servers.ts
-async function serversCommand(options = {}) {
+// src/cli/commands/deployments.ts
+init_dist();
+var import_cli_table36 = __toESM(require_table(), 1);
+async function deploymentsCommand(uuid, options = {}) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
+    return;
+  }
+  uuid = resolvedUuid;
   const coolify = getCoolifyService();
   const initResult = await coolify.init();
   if (isErr(initResult)) {
     console.error(source_default.red(`Error: ${initResult.error.message}`));
     return;
   }
-  const result = await coolify.listServers();
+  const result = await coolify.getApplicationDeploymentHistory(uuid);
   if (isErr(result)) {
     console.error(source_default.red(`Error: ${result.error.message}`));
     return;
   }
-  const servers = result.value;
-  if (servers.length === 0) {
-    console.log(source_default.yellow("No servers found"));
+  let deployments = result.value;
+  deployments = deployments.reverse();
+  if (options.limit) {
+    deployments = deployments.slice(0, options.limit);
+  }
+  if (deployments.length === 0) {
+    console.log(source_default.yellow("No deployments found"));
     return;
   }
-  const table = createTable(["UUID", "Name", "IP", "Status"], [options.full ? 36 : 8, 25, 20, 15]);
-  for (const server of servers) {
-    const statusColor = server.is_usable ? source_default.green : source_default.red;
+  const table = new import_cli_table36.default({
+    head: [
+      source_default.cyan("ID"),
+      source_default.cyan("UUID"),
+      source_default.cyan("Status"),
+      source_default.cyan("Commit"),
+      source_default.cyan("Created")
+    ],
+    ...options.full ? { colWidths: [8, 36, 20, 10, 20] } : {}
+  });
+  for (const dep of deployments) {
     table.push([
-      options.full ? server.uuid : server.uuid.slice(0, 8),
-      server.name,
-      server.ip || "N/A",
-      statusColor(server.is_usable ? "● Usable" : "○ Unusable")
+      String(dep.id),
+      dep.uuid || "-",
+      formatStatus(dep.status),
+      dep.commit?.slice(0, 7) || "-",
+      new Date(dep.created_at).toLocaleString()
     ]);
   }
   console.log(table.toString());
-  console.log(source_default.gray(`Total: ${servers.length} server(s)`));
+  console.log(source_default.gray(`Total: ${deployments.length} deployment(s)`));
 }
 
-// src/cli/commands/projects.ts
-var import_cli_table33 = __toESM(require_table(), 1);
-async function projectsCommand(options = {}) {
-  const spinner = ora("Connecting to Coolify...").start();
+// src/cli/commands/start.ts
+init_dist();
+async function startCommand(uuid) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
+    return;
+  }
+  uuid = resolvedUuid;
+  const spinner = ora("Initializing Coolify connection...").start();
   try {
     const coolify = getCoolifyService();
     const initResult = await coolify.init();
@@ -11936,56 +13496,28 @@ async function projectsCommand(options = {}) {
       spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
       return;
     }
-    if (options.create) {
-      spinner.text = `Creating project "${options.create}"...`;
-      const createResult = await coolify.createProject(options.create, options.description);
-      if (isOk(createResult)) {
-        spinner.succeed(source_default.green(`Project created: ${source_default.cyan(createResult.value.uuid)}`));
-        console.log(`  Name: ${source_default.cyan(options.create)}`);
-        console.log(`  UUID: ${source_default.cyan(createResult.value.uuid)}`);
-      } else {
-        spinner.fail(source_default.red(`Failed to create project: ${createResult.error.message}`));
-      }
+    spinner.text = "Starting application...";
+    const result = await coolify.startApplication(uuid);
+    if (isErr(result)) {
+      spinner.fail(source_default.red(`Failed to start application: ${result.error.message}`));
       return;
     }
-    spinner.text = "Fetching projects...";
-    const result = await coolify.listProjects();
-    if (isOk(result)) {
-      spinner.succeed(source_default.green("Projects retrieved"));
-      const projects = result.value;
-      if (projects.length === 0) {
-        console.log(source_default.yellow("No projects found"));
-        return;
-      }
-      const table = new import_cli_table33.default({
-        head: [
-          source_default.cyan("UUID"),
-          source_default.cyan("Name"),
-          source_default.cyan("Description")
-        ],
-        ...options.full ? { colWidths: [36, 30, 40] } : {}
-      });
-      for (const project of projects) {
-        table.push([
-          options.full ? project.uuid : project.uuid.slice(0, 8),
-          project.name,
-          project.description || "-"
-        ]);
-      }
-      console.log(table.toString());
-      console.log(source_default.gray(`Total: ${projects.length} project(s)`));
-    } else {
-      spinner.fail(source_default.red(`Failed to fetch projects: ${result.error.message}`));
-    }
+    spinner.succeed(source_default.green(`Application started: ${source_default.cyan(uuid)}`));
   } catch (error) {
     spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
   }
 }
 
-// src/cli/commands/environments.ts
-var import_cli_table34 = __toESM(require_table(), 1);
-async function environmentsCommand(projectUuid, options = {}) {
-  const spinner = ora("Connecting to Coolify...").start();
+// src/cli/commands/stop.ts
+init_dist();
+async function stopCommand(uuid) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
+    return;
+  }
+  uuid = resolvedUuid;
+  const spinner = ora("Initializing Coolify connection...").start();
   try {
     const coolify = getCoolifyService();
     const initResult = await coolify.init();
@@ -11993,394 +13525,1042 @@ async function environmentsCommand(projectUuid, options = {}) {
       spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
       return;
     }
-    spinner.text = `Fetching environments for project ${projectUuid.slice(0, 8)}...`;
-    const result = await coolify.getProjectEnvironments(projectUuid);
-    if (isOk(result)) {
-      spinner.succeed(source_default.green("Environments retrieved"));
-      const environments = result.value;
-      if (environments.length === 0) {
-        console.log(source_default.yellow("No environments found for this project"));
-        return;
-      }
-      const table = new import_cli_table34.default({
-        head: [
-          source_default.cyan("UUID"),
-          source_default.cyan("Name"),
-          source_default.cyan("Description")
-        ],
-        ...options.full ? { colWidths: [36, 25, 40] } : {}
-      });
-      for (const env2 of environments) {
-        table.push([
-          options.full ? env2.uuid : env2.uuid.slice(0, 8),
-          env2.name,
-          env2.description || "-"
-        ]);
-      }
-      console.log(table.toString());
-      console.log(source_default.gray(`Total: ${environments.length} environment(s)`));
-    } else {
-      spinner.fail(source_default.red(`Failed to fetch environments: ${result.error.message}`));
+    spinner.text = "Stopping application...";
+    const result = await coolify.stopApplication(uuid);
+    if (isErr(result)) {
+      spinner.fail(source_default.red(`Failed to stop application: ${result.error.message}`));
+      return;
     }
+    spinner.succeed(source_default.green(`Application stopped: ${source_default.cyan(uuid)}`));
   } catch (error) {
     spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
   }
 }
 
-// src/cli/commands/config.ts
-import { existsSync as existsSync2 } from "node:fs";
-async function configCommand(action, args) {
-  if (action === "set") {
-    if (!args.key || !args.value) {
-      console.error(source_default.red('Error: key and value are required for "set" command'));
-      console.log(source_default.gray("Usage: coolify-mcp config set <key> <value>"));
-      console.log(source_default.gray("Keys: url, token"));
+// src/cli/commands/restart.ts
+init_dist();
+async function restartCommand(uuid) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
+    return;
+  }
+  uuid = resolvedUuid;
+  const spinner = ora("Initializing Coolify connection...").start();
+  try {
+    const coolify = getCoolifyService();
+    const initResult = await coolify.init();
+    if (isErr(initResult)) {
+      spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
       return;
     }
-    const result = await loadConfig();
-    if (isOk(result)) {
-      const config = result.value;
-      if (args.key === "url") {
-        config.url = args.value;
-      } else if (args.key === "token") {
-        config.token = args.value;
-      } else {
-        console.error(source_default.red(`Error: Unknown key "${args.key}"`));
-        return;
-      }
-      const saveResult = await saveConfig(config);
-      if (isOk(saveResult)) {
-        console.log(source_default.green(`Config updated: ${args.key} = ${args.value}`));
-      } else {
-        console.error(source_default.red(`Error: ${saveResult.error.message}`));
-      }
-    }
-  } else if (action === "get") {
-    const result = await loadConfig();
-    if (isOk(result)) {
-      const config = result.value;
-      console.log(source_default.cyan("Current configuration:"));
-      console.log(`  URL: ${source_default.gray(config.url || "(not set)")}`);
-      console.log(`  Token: ${source_default.gray(config.token ? "(set)" : "(not set)")}`);
-    } else {
-      console.error(source_default.red(`Error: ${result.error.message}`));
-    }
-  } else if (action === "path") {
-    console.log(source_default.cyan("Config file:"));
-    console.log(`  ${CONFIG_FILE}`);
-    if (existsSync2(CONFIG_FILE)) {
-      console.log(source_default.gray("  Status: File exists"));
-    } else {
-      console.log(source_default.yellow("  Status: File does not exist"));
+    spinner.text = "Restarting application...";
+    const result = await coolify.restartApplication(uuid);
+    if (isErr(result)) {
+      spinner.fail(source_default.red(`Failed to restart application: ${result.error.message}`));
+      return;
     }
-  } else {
-    console.log(source_default.cyan("Coolify MCP Configuration"));
-    console.log();
-    console.log(source_default.gray("Commands:"));
-    console.log("  coolify-mcp config set <key> <value>  Set a config value");
-    console.log("  coolify-mcp config get                 Show current config");
-    console.log("  coolify-mcp config path                Show config file path");
-    console.log();
-    console.log(source_default.gray("Keys:"));
-    console.log("  url    - Coolify instance URL");
-    console.log("  token  - Coolify API token");
-    console.log();
-    console.log(source_default.gray("Environment variables:"));
-    console.log("  COOLIFY_URL     - Coolify instance URL");
-    console.log("  COOLIFY_TOKEN   - Coolify API token");
+    spinner.succeed(source_default.green(`Application restarted: ${source_default.cyan(uuid)}`));
+  } catch (error) {
+    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+
+// src/cli/commands/build-logs.ts
+init_dist();
+async function buildLogsCommand(deploymentUuid, options) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.getDeploymentLogs(deploymentUuid);
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  const { status, logs } = result.value;
+  console.log(source_default.cyan("Deployment:") + " " + source_default.white(deploymentUuid));
+  console.log(source_default.cyan("Status:    ") + " " + source_default.white(status));
+  console.log("");
+  if (!logs || logs.length === 0) {
+    console.log(source_default.yellow("No build logs available"));
+    return;
+  }
+  const lines = logs.split(`
+`);
+  const tail = options.lines || lines.length;
+  const output = lines.slice(-tail);
+  console.log(source_default.gray(`Build logs (${output.length} lines):
+`));
+  for (const line of output) {
+    console.log(line);
+  }
+}
+
+// src/cli/commands/service-logs.ts
+init_dist();
+async function serviceLogsCommand(uuid, serviceName, options) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.getApplicationLogs(uuid, {
+    tail: options.lines || 50,
+    serviceName
+  });
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  const logs = result.value;
+  if (logs.logs.length === 0) {
+    console.log(source_default.yellow(`No logs available for service "${serviceName}"`));
+    return;
+  }
+  console.log(source_default.gray(`Service "${source_default.white(serviceName)}" logs (${logs.logs.length} lines):
+`));
+  for (const line of logs.logs) {
+    console.log(line);
   }
 }
 
-// src/cli/commands/env.ts
-async function envCommand(uuid, options = {}) {
+// src/cli/commands/version.ts
+init_dist();
+async function versionCommand() {
   const coolify = getCoolifyService();
   const initResult = await coolify.init();
   if (isErr(initResult)) {
     console.error(source_default.red(`Error: ${initResult.error.message}`));
     return;
   }
-  if (options.set) {
-    const [key, ...valueParts] = options.set.split("=");
-    const value = valueParts.join("=");
-    if (!key || value === undefined) {
-      console.error(source_default.red("Error: Invalid format. Use --set KEY=VALUE"));
-      return;
-    }
-    const result2 = await coolify.setEnvironmentVariable(uuid, key, value, options.buildtime ?? false);
-    if (isErr(result2)) {
-      console.error(source_default.red(`Error: ${result2.error.message}`));
-      return;
-    }
-    console.log(source_default.green(`✓ Set ${source_default.bold(key)} for ${uuid.slice(0, 8)}`));
+  const result = await coolify.getVersion();
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
     return;
   }
-  if (options.delete) {
-    const result2 = await coolify.deleteEnvironmentVariable(uuid, options.delete);
-    if (isErr(result2)) {
-      console.error(source_default.red(`Error: ${result2.error.message}`));
-      return;
-    }
-    console.log(source_default.green(`✓ Deleted ${source_default.bold(options.delete)} from ${uuid.slice(0, 8)}`));
+  console.log(source_default.cyan("Coolify Server Version:"), source_default.bold(result.value.version));
+}
+
+// src/cli/commands/databases.ts
+init_dist();
+var import_cli_table37 = __toESM(require_table(), 1);
+async function databasesCommand(_options = {}) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
     return;
   }
-  const result = await coolify.getEnvironmentVariables(uuid);
+  const result = await coolify.listDatabases();
   if (isErr(result)) {
     console.error(source_default.red(`Error: ${result.error.message}`));
     return;
   }
-  const envVars = result.value;
-  if (envVars.length === 0) {
-    console.log(source_default.yellow("No environment variables found"));
+  const databases = result.value;
+  if (databases.length === 0) {
+    console.log(source_default.yellow("No databases found"));
     return;
   }
-  console.log(source_default.cyan(`Environment variables (${envVars.length}):
-`));
-  const runtimeVars = envVars.filter((ev) => ev.is_runtime);
-  const buildtimeVars = envVars.filter((ev) => ev.is_buildtime);
-  if (runtimeVars.length > 0) {
-    console.log(source_default.yellow.bold("Runtime:"));
-    for (const ev of runtimeVars) {
-      const required = ev.is_required ? source_default.red(" *") : "";
-      console.log(`  ${source_default.green(ev.key)}${required} = ${source_default.gray(ev.value)}`);
-    }
-    console.log();
+  const table = new import_cli_table37.default({
+    head: [
+      source_default.cyan("UUID"),
+      source_default.cyan("Name"),
+      source_default.cyan("Type"),
+      source_default.cyan("Status")
+    ]
+  });
+  for (const db of databases) {
+    table.push([
+      db.uuid,
+      db.name || "-",
+      db.type || "-",
+      formatStatus(db.status)
+    ]);
   }
-  if (buildtimeVars.length > 0) {
-    console.log(source_default.blue.bold("Buildtime:"));
-    for (const ev of buildtimeVars) {
-      console.log(`  ${source_default.green(ev.key)} = ${source_default.gray(ev.value)}`);
-    }
+  console.log(table.toString());
+  console.log(source_default.gray(`Total: ${databases.length} database(s)`));
+}
+
+// src/cli/commands/services.ts
+init_dist();
+var import_cli_table38 = __toESM(require_table(), 1);
+async function servicesCommand(_options = {}) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.listServices();
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  const services = result.value;
+  if (services.length === 0) {
+    console.log(source_default.yellow("No services found"));
+    return;
+  }
+  const table = new import_cli_table38.default({
+    head: [
+      source_default.cyan("UUID"),
+      source_default.cyan("Name"),
+      source_default.cyan("Type"),
+      source_default.cyan("Status")
+    ]
+  });
+  for (const svc of services) {
+    table.push([
+      svc.uuid,
+      svc.name || "-",
+      svc.type || "-",
+      formatStatus(svc.status)
+    ]);
   }
+  console.log(table.toString());
+  console.log(source_default.gray(`Total: ${services.length} service(s)`));
 }
 
-// src/cli/commands/update.ts
-async function updateCommand(options) {
-  console.log(source_default.cyan(`Updating application ${source_default.bold(options.uuid)}...`));
-  const service = getCoolifyService();
-  const initResult = await service.init();
+// src/cli/commands/cancel-deploy.ts
+init_dist();
+async function cancelDeployCommand(deploymentUuid) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
   if (isErr(initResult)) {
-    console.error(source_default.red("Failed to initialize Coolify service"));
-    console.error(source_default.gray(initResult.error.message));
-    process.exit(1);
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
   }
-  const updateOptions = {};
-  if (options.name)
-    updateOptions.name = options.name;
-  if (options.description)
-    updateOptions.description = options.description;
-  if (options.buildPack)
-    updateOptions.buildPack = options.buildPack;
-  if (options.gitBranch)
-    updateOptions.gitBranch = options.gitBranch;
-  if (options.ports)
-    updateOptions.portsExposes = options.ports;
-  if (options.installCommand)
-    updateOptions.installCommand = options.installCommand;
-  if (options.buildCommand)
-    updateOptions.buildCommand = options.buildCommand;
-  if (options.startCommand)
-    updateOptions.startCommand = options.startCommand;
-  if (options.dockerfileLocation)
-    updateOptions.dockerfileLocation = options.dockerfileLocation;
-  if (options.baseDirectory)
-    updateOptions.baseDirectory = options.baseDirectory;
-  if (options.domains)
-    updateOptions.domains = options.domains;
-  if (options.autoDeploy !== undefined)
-    updateOptions.isAutoDeployEnabled = options.autoDeploy;
-  if (options.forceHttps)
-    updateOptions.isForceHttpsEnabled = true;
-  if (Object.keys(updateOptions).length === 0) {
-    console.warn(source_default.yellow("No update options provided. Use --help to see available options."));
-    process.exit(0);
+  const result = await coolify.cancelDeployment(deploymentUuid);
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  console.log(source_default.green(`Deployment ${deploymentUuid} cancelled`));
+}
+
+// src/cli/commands/server-resources.ts
+init_dist();
+var import_cli_table39 = __toESM(require_table(), 1);
+async function serverResourcesCommand(serverUuid, _options = {}) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.getServerResources(serverUuid);
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  const resources = result.value;
+  if (resources.length === 0) {
+    console.log(source_default.yellow("No resources found on this server"));
+    return;
+  }
+  const table = new import_cli_table39.default({
+    head: [
+      source_default.cyan("UUID"),
+      source_default.cyan("Name"),
+      source_default.cyan("Type"),
+      source_default.cyan("Status")
+    ]
+  });
+  for (const res of resources) {
+    table.push([
+      res.uuid,
+      res.name || "-",
+      res.type || "-",
+      formatStatus(res.status)
+    ]);
+  }
+  console.log(table.toString());
+  console.log(source_default.gray(`Total: ${resources.length} resource(s) on server ${serverUuid}`));
+}
+
+// src/cli/actions.ts
+var import_cli_table310 = __toESM(require_table(), 1);
+
+// src/sdk.ts
+init_dist();
+function unwrap(result) {
+  if (isErr(result))
+    throw result.error;
+  return result.value;
+}
+
+class ApplicationsResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async list(options) {
+    return unwrap(await this.svc.listApplications(options?.teamId, options?.projectId, options?.page, options?.perPage));
+  }
+  async listSummaries() {
+    return unwrap(await this.svc.listApplicationSummaries());
+  }
+  async resolve(query) {
+    return unwrap(await this.svc.resolveApplication(query));
+  }
+  async create(options, onProgress) {
+    return unwrap(await this.svc.createApplication(options, onProgress));
+  }
+  async deploy(uuid, options, onProgress) {
+    return unwrap(await this.svc.deploy({ uuid, ...options }, onProgress));
+  }
+  async start(uuid, options) {
+    return unwrap(await this.svc.startApplication(uuid, options));
+  }
+  async stop(uuid) {
+    return unwrap(await this.svc.stopApplication(uuid));
+  }
+  async restart(uuid) {
+    return unwrap(await this.svc.restartApplication(uuid));
+  }
+  async delete(uuid, options) {
+    return unwrap(await this.svc.deleteApplication(uuid, options));
+  }
+  async update(uuid, options) {
+    return unwrap(await this.svc.updateApplication(uuid, options));
+  }
+  async logs(uuid, options) {
+    return unwrap(await this.svc.getApplicationLogs(uuid, options));
+  }
+  async deployments(uuid, skip, take) {
+    return unwrap(await this.svc.getApplicationDeployments(uuid, skip, take));
+  }
+  async exec(uuid, command) {
+    return unwrap(await this.svc.executeCommand(uuid, command));
+  }
+  async envVars(uuid) {
+    return unwrap(await this.svc.getEnvironmentVariables(uuid));
+  }
+  async setEnv(uuid, key, value, isBuildTime) {
+    return unwrap(await this.svc.setEnvironmentVariable(uuid, key, value, isBuildTime));
+  }
+  async bulkSetEnv(uuid, vars) {
+    return unwrap(await this.svc.bulkUpdateEnvironmentVariables(uuid, vars));
+  }
+  async deleteEnv(uuid, key) {
+    return unwrap(await this.svc.deleteEnvironmentVariable(uuid, key));
+  }
+}
+
+class DatabasesResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async list(options) {
+    return unwrap(await this.svc.listDatabases(options?.page, options?.perPage));
+  }
+  async listSummaries() {
+    return unwrap(await this.svc.listDatabaseSummaries());
+  }
+  async get(uuid) {
+    return unwrap(await this.svc.getDatabase(uuid));
+  }
+  async create(type, data) {
+    return unwrap(await this.svc.createDatabase(type, data));
+  }
+  async update(uuid, data) {
+    return unwrap(await this.svc.updateDatabase(uuid, data));
+  }
+  async start(uuid) {
+    return unwrap(await this.svc.startDatabase(uuid));
+  }
+  async stop(uuid) {
+    return unwrap(await this.svc.stopDatabase(uuid));
+  }
+  async restart(uuid) {
+    return unwrap(await this.svc.restartDatabase(uuid));
+  }
+  async delete(uuid, options) {
+    return unwrap(await this.svc.deleteDatabase(uuid, options));
+  }
+  async backups(uuid) {
+    return unwrap(await this.svc.listDatabaseBackups(uuid));
+  }
+  async getBackup(dbUuid, backupUuid) {
+    return unwrap(await this.svc.getDatabaseBackup(dbUuid, backupUuid));
+  }
+  async createBackup(dbUuid, data) {
+    return unwrap(await this.svc.createDatabaseBackup(dbUuid, data));
+  }
+  async deleteBackup(dbUuid, backupUuid) {
+    return unwrap(await this.svc.deleteDatabaseBackup(dbUuid, backupUuid));
+  }
+}
+
+class ServicesResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async list(options) {
+    return unwrap(await this.svc.listServices(options?.page, options?.perPage));
+  }
+  async listSummaries() {
+    return unwrap(await this.svc.listServiceSummaries());
+  }
+  async get(uuid) {
+    return unwrap(await this.svc.getService(uuid));
+  }
+  async create(data) {
+    return unwrap(await this.svc.createService(data));
+  }
+  async update(uuid, data) {
+    return unwrap(await this.svc.updateService(uuid, data));
+  }
+  async start(uuid) {
+    return unwrap(await this.svc.startService(uuid));
+  }
+  async stop(uuid) {
+    return unwrap(await this.svc.stopService(uuid));
+  }
+  async restart(uuid) {
+    return unwrap(await this.svc.restartService(uuid));
+  }
+  async delete(uuid, options) {
+    return unwrap(await this.svc.deleteService(uuid, options));
+  }
+  async envVars(uuid) {
+    return unwrap(await this.svc.listServiceEnvVars(uuid));
+  }
+  async setEnv(uuid, data) {
+    return unwrap(await this.svc.createServiceEnvVar(uuid, data));
+  }
+}
+
+class ServersResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async list(options) {
+    return unwrap(await this.svc.listServers(options?.page, options?.perPage));
+  }
+  async listSummaries() {
+    return unwrap(await this.svc.listServerSummaries());
+  }
+  async resolve(query) {
+    return unwrap(await this.svc.resolveServer(query));
+  }
+  async get(uuid) {
+    return unwrap(await this.svc.getServer(uuid));
+  }
+  async create(data) {
+    return unwrap(await this.svc.createServer(data));
+  }
+  async delete(uuid) {
+    return unwrap(await this.svc.deleteServer(uuid));
+  }
+  async resources(uuid) {
+    return unwrap(await this.svc.getServerResources(uuid));
+  }
+  async domains(uuid) {
+    return unwrap(await this.svc.getServerDomains(uuid));
+  }
+  async destinations(uuid) {
+    return unwrap(await this.svc.getServerDestinations(uuid));
+  }
+  async validate(uuid) {
+    return unwrap(await this.svc.validateServer(uuid));
+  }
+}
+
+class ProjectsResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async list(options) {
+    return unwrap(await this.svc.listProjects(options?.page, options?.perPage));
+  }
+  async create(name, description) {
+    return unwrap(await this.svc.createProject(name, description));
+  }
+  async update(uuid, data) {
+    return unwrap(await this.svc.updateProject(uuid, data));
+  }
+  async delete(uuid) {
+    return unwrap(await this.svc.deleteProject(uuid));
+  }
+  async environments(projectUuid) {
+    return unwrap(await this.svc.getProjectEnvironments(projectUuid));
+  }
+  async createEnvironment(projectUuid, data) {
+    return unwrap(await this.svc.createProjectEnvironment(projectUuid, data));
+  }
+}
+
+class TeamsResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async list(options) {
+    return unwrap(await this.svc.listTeams(options?.page, options?.perPage));
+  }
+  async current() {
+    return unwrap(await this.svc.getCurrentTeam());
+  }
+  async get(id) {
+    return unwrap(await this.svc.getTeam(id));
+  }
+  async members(teamId) {
+    return unwrap(await this.svc.getTeamMembers(teamId));
+  }
+}
+
+class KeysResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async list() {
+    return unwrap(await this.svc.listPrivateKeys());
+  }
+  async get(uuid) {
+    return unwrap(await this.svc.getPrivateKey(uuid));
+  }
+  async create(data) {
+    return unwrap(await this.svc.createPrivateKey(data));
+  }
+  async update(uuid, data) {
+    return unwrap(await this.svc.updatePrivateKey(uuid, data));
+  }
+  async delete(uuid) {
+    return unwrap(await this.svc.deletePrivateKey(uuid));
+  }
+}
+
+class DeploymentsResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
   }
-  const result = await service.updateApplication(options.uuid, updateOptions);
-  if (isErr(result)) {
-    console.error(source_default.red("Failed to update application"));
-    console.error(source_default.gray(result.error.message));
-    process.exit(1);
+  async active(options) {
+    return unwrap(await this.svc.listDeployments(options?.page, options?.perPage));
   }
-  console.log(source_default.green("Application updated successfully"));
-  console.log(source_default.gray(`UUID: ${result.value.uuid}`));
-  console.log(source_default.gray(`Name: ${result.value.name}`));
-  if (result.value.description) {
-    console.log(source_default.gray(`Description: ${result.value.description}`));
+  async get(uuid) {
+    return unwrap(await this.svc.getDeployment(uuid));
+  }
+  async logs(uuid) {
+    return unwrap(await this.svc.getDeploymentLogs(uuid));
+  }
+  async cancel(uuid) {
+    return unwrap(await this.svc.cancelDeployment(uuid));
   }
 }
 
-// src/cli/commands/delete.ts
-async function deleteCommand(uuid, options = {}) {
-  const service = getCoolifyService();
-  const initResult = await service.init();
-  if (isErr(initResult)) {
-    console.error(source_default.red("Failed to initialize Coolify service"));
-    console.error(source_default.gray(initResult.error.message));
-    process.exit(1);
+class DiagnoseResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
   }
-  if (!options.force && !options.yes) {
-    const readline = await import("readline");
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    const answer = await new Promise((resolve) => {
-      rl.question(source_default.yellow(`Are you sure you want to delete application ${source_default.bold(uuid)}? (yes/no): `), (ans) => {
-        rl.close();
-        resolve(ans.toLowerCase());
+  async app(query) {
+    return unwrap(await this.svc.diagnoseApplication(query));
+  }
+  async server(query) {
+    return unwrap(await this.svc.diagnoseServer(query));
+  }
+  async infrastructure() {
+    return unwrap(await this.svc.findInfrastructureIssues());
+  }
+  async deployFailure(deploymentUuid) {
+    const { analyzeDeployFailure: analyzeDeployFailure2 } = await Promise.resolve().then(() => (init_network(), exports_network));
+    return unwrap(await analyzeDeployFailure2(this.svc, deploymentUuid));
+  }
+}
+
+class NetworkResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async inspect(appUuid, servicesToTest) {
+    const { inspectNetwork: inspectNetwork2 } = await Promise.resolve().then(() => (init_network(), exports_network));
+    return unwrap(await inspectNetwork2(this.svc, appUuid, servicesToTest));
+  }
+}
+
+class BatchResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async restartProject(projectUuid) {
+    return unwrap(await this.svc.restartProjectApps(projectUuid));
+  }
+  async redeployProject(projectUuid, force) {
+    return unwrap(await this.svc.redeployProjectApps(projectUuid, force));
+  }
+  async stopAll() {
+    return unwrap(await this.svc.stopAllApps());
+  }
+}
+
+class GitHubAppsResource {
+  svc;
+  constructor(svc) {
+    this.svc = svc;
+  }
+  async list(options) {
+    return unwrap(await this.svc.listGithubApps(options?.page, options?.perPage));
+  }
+  async create(data) {
+    return unwrap(await this.svc.createGitHubApp(data));
+  }
+  async update(id, data) {
+    return unwrap(await this.svc.updateGitHubApp(id, data));
+  }
+  async delete(id) {
+    return unwrap(await this.svc.deleteGitHubApp(id));
+  }
+}
+
+class Coolify {
+  svc;
+  initialized = false;
+  applications;
+  databases;
+  services;
+  servers;
+  projects;
+  teams;
+  keys;
+  deployments;
+  diagnose;
+  network;
+  batch;
+  githubApps;
+  constructor(options) {
+    this.svc = new CoolifyService;
+    if (options) {
+      process.env.COOLIFY_URL = options.url;
+      process.env.COOLIFY_TOKEN = options.token;
+    }
+    const autoInit = (resource) => {
+      return new Proxy(resource, {
+        get: (target, prop, receiver) => {
+          const value = Reflect.get(target, prop, receiver);
+          if (typeof value !== "function")
+            return value;
+          return async (...args) => {
+            await this.ensureInit();
+            return value.apply(target, args);
+          };
+        }
       });
-    });
-    if (answer !== "yes" && answer !== "y") {
-      console.log(source_default.gray("Operation cancelled"));
-      process.exit(0);
+    };
+    this.applications = autoInit(new ApplicationsResource(this.svc));
+    this.databases = autoInit(new DatabasesResource(this.svc));
+    this.services = autoInit(new ServicesResource(this.svc));
+    this.servers = autoInit(new ServersResource(this.svc));
+    this.projects = autoInit(new ProjectsResource(this.svc));
+    this.teams = autoInit(new TeamsResource(this.svc));
+    this.keys = autoInit(new KeysResource(this.svc));
+    this.deployments = autoInit(new DeploymentsResource(this.svc));
+    this.diagnose = autoInit(new DiagnoseResource(this.svc));
+    this.network = autoInit(new NetworkResource(this.svc));
+    this.batch = autoInit(new BatchResource(this.svc));
+    this.githubApps = autoInit(new GitHubAppsResource(this.svc));
+  }
+  static fromEnv() {
+    return new Coolify;
+  }
+  async ensureInit() {
+    if (this.initialized)
+      return;
+    const initResult = await this.svc.init();
+    if (isErr(initResult)) {
+      throw new Error(`Coolify connection failed: ${initResult.error.message}`);
     }
+    this.initialized = true;
   }
-  console.log(source_default.cyan(`Deleting application ${source_default.bold(uuid)}...`));
-  const result = await service.deleteApplication(uuid);
-  if (isErr(result)) {
-    console.error(source_default.red("Failed to delete application"));
-    console.error(source_default.gray(result.error.message));
-    process.exit(1);
-  }
-  console.log(source_default.green("Application deleted successfully"));
-  if (result.value.message) {
-    console.log(source_default.gray(result.value.message));
+  async version() {
+    await this.ensureInit();
+    return unwrap(await this.svc.getVersion());
   }
 }
 
-// src/cli/commands/destinations.ts
-var import_cli_table35 = __toESM(require_table(), 1);
-async function destinationsCommand(serverUuid) {
-  const coolify = getCoolifyService();
-  const initResult = await coolify.init();
-  if (isErr(initResult)) {
-    console.error(source_default.red(`Error: ${initResult.error.message}`));
+// src/cli/actions.ts
+var _sdk = null;
+function getSdk() {
+  if (!_sdk)
+    _sdk = Coolify.fromEnv();
+  return _sdk;
+}
+async function runAction(uuid, actionLabel, callFn, successMsg) {
+  const resolved = resolveUuid(uuid);
+  if (!resolved) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
     return;
   }
-  const result = await coolify.getServerDestinations(serverUuid);
-  if (isErr(result)) {
-    console.error(source_default.red(`Error: ${result.error.message}`));
+  const spinner = ora("Connecting to Coolify...").start();
+  try {
+    spinner.text = `${actionLabel}...`;
+    await callFn(getSdk(), resolved);
+    spinner.succeed(source_default.green(successMsg(resolved)));
+  } catch (error) {
+    spinner.fail(source_default.red(`Failed: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+async function runList(resourceLabel, callFn, columns) {
+  try {
+    const items = await callFn(getSdk());
+    if (items.length === 0) {
+      console.log(source_default.yellow(`No ${resourceLabel} found`));
+      return;
+    }
+    const table = new import_cli_table310.default({
+      head: columns.map((c) => source_default.cyan(c.header))
+    });
+    for (const item of items) {
+      table.push(columns.map((c) => c.value(item)));
+    }
+    console.log(table.toString());
+    console.log(source_default.gray(`Total: ${items.length} ${resourceLabel}`));
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+async function runGet(uuid, _resourceLabel, callFn, formatFn) {
+  const resolved = resolveUuid(uuid);
+  if (!resolved) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
     return;
   }
-  const destinations = result.value;
-  if (destinations.length === 0) {
-    console.log(source_default.yellow("No destinations found"));
+  try {
+    const item = await callFn(getSdk(), resolved);
+    formatFn(item);
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+function getCliSdk() {
+  return getSdk();
+}
+
+// src/cli/commands/db.ts
+var dbListCommand = () => runList("database(s)", (s) => s.databases.list(), [
+  { header: "UUID", value: (d) => d.uuid },
+  { header: "Name", value: (d) => d.name || "-" },
+  { header: "Type", value: (d) => d.type || "-" },
+  { header: "Status", value: (d) => formatStatus(d.status) }
+]);
+var dbGetCommand = (uuid) => runGet(uuid, "database", (s, u) => s.databases.get(u), (db) => {
+  console.log(source_default.cyan("Database Details:"));
+  console.log(source_default.gray("UUID:   ") + db.uuid);
+  console.log(source_default.gray("Name:   ") + db.name);
+  console.log(source_default.gray("Type:   ") + (db.type || "-"));
+  console.log(source_default.gray("Status: ") + formatStatus(db.status));
+});
+var dbStartCommand = (uuid) => runAction(uuid, "Starting database", (s, u) => s.databases.start(u), (u) => `Database started: ${u}`);
+var dbStopCommand = (uuid) => runAction(uuid, "Stopping database", (s, u) => s.databases.stop(u), (u) => `Database stopped: ${u}`);
+var dbRestartCommand = (uuid) => runAction(uuid, "Restarting database", (s, u) => s.databases.restart(u), (u) => `Database restarted: ${u}`);
+var dbDeleteCommand = (uuid) => runAction(uuid, "Deleting database", (s, u) => s.databases.delete(u), (u) => `Database deleted: ${u}`);
+
+// src/cli/commands/svc.ts
+var svcListCommand = () => runList("service(s)", (s) => s.services.list(), [
+  { header: "UUID", value: (s) => s.uuid },
+  { header: "Name", value: (s) => s.name || "-" },
+  { header: "Type", value: (s) => s.type || "-" },
+  { header: "Status", value: (s) => formatStatus(s.status) }
+]);
+var svcGetCommand = (uuid) => runGet(uuid, "service", (s, u) => s.services.get(u), (svc) => {
+  console.log(source_default.cyan("Service Details:"));
+  console.log(source_default.gray("UUID:   ") + svc.uuid);
+  console.log(source_default.gray("Name:   ") + svc.name);
+  console.log(source_default.gray("Type:   ") + (svc.type || "-"));
+  console.log(source_default.gray("Status: ") + formatStatus(svc.status));
+});
+var svcStartCommand = (uuid) => runAction(uuid, "Starting service", (s, u) => s.services.start(u), (u) => `Service started: ${u}`);
+var svcStopCommand = (uuid) => runAction(uuid, "Stopping service", (s, u) => s.services.stop(u), (u) => `Service stopped: ${u}`);
+var svcRestartCommand = (uuid) => runAction(uuid, "Restarting service", (s, u) => s.services.restart(u), (u) => `Service restarted: ${u}`);
+var svcDeleteCommand = (uuid) => runAction(uuid, "Deleting service", (s, u) => s.services.delete(u), (u) => `Service deleted: ${u}`);
+
+// src/cli/commands/keys.ts
+var keysListCommand = () => runList("key(s)", (s) => s.keys.list(), [
+  { header: "UUID", value: (k) => k.uuid },
+  { header: "Name", value: (k) => k.name || "-" },
+  { header: "Git?", value: (k) => k.is_git_related ? "Yes" : "No" },
+  {
+    header: "Created",
+    value: (k) => k.created_at ? new Date(k.created_at).toLocaleDateString() : "-"
+  }
+]);
+var keysGetCommand = (uuid) => runGet(uuid, "private key", (s, u) => s.keys.get(u), (key) => {
+  console.log(source_default.cyan("Private Key Details:"));
+  console.log(source_default.gray("UUID:       ") + key.uuid);
+  console.log(source_default.gray("Name:       ") + key.name);
+  console.log(source_default.gray("Git-related:") + (key.is_git_related ? " Yes" : " No"));
+});
+var keysDeleteCommand = (uuid) => runAction(uuid, "Deleting private key", (s, u) => s.keys.delete(u), (u) => `Private key deleted: ${u}`);
+
+// src/cli/commands/teams.ts
+var teamsListCommand = () => runList("team(s)", (s) => s.teams.list(), [
+  { header: "ID", value: (t) => String(t.id) },
+  { header: "Name", value: (t) => t.name },
+  { header: "Personal", value: (t) => t.personal_team ? "Yes" : "No" }
+]);
+async function teamsCurrentCommand() {
+  try {
+    const team = await getCliSdk().teams.current();
+    console.log(source_default.cyan("Current Team:"));
+    console.log(source_default.gray("ID:       ") + team.id);
+    console.log(source_default.gray("Name:     ") + team.name);
+    console.log(source_default.gray("Personal: ") + (team.personal_team ? "Yes" : "No"));
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+async function teamsMembersCommand(teamId) {
+  const id = parseInt(teamId, 10);
+  if (isNaN(id)) {
+    console.error(source_default.red("Error: Team ID must be a number"));
     return;
   }
-  const table = new import_cli_table35.default({
-    head: [
-      source_default.cyan("UUID"),
-      source_default.cyan("Name"),
-      source_default.cyan("Network")
-    ]
-  });
-  for (const dest of destinations) {
-    table.push([
-      dest.uuid,
-      dest.name,
-      dest.network || "N/A"
-    ]);
+  try {
+    const members = await getCliSdk().teams.members(id);
+    if (members.length === 0) {
+      console.log(source_default.yellow("No members found"));
+      return;
+    }
+    console.log(source_default.cyan(`Team ${teamId} Members:`));
+    for (const m of members) {
+      console.log(`  ${source_default.bold(m.name)} (${source_default.gray(m.email)})`);
+    }
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
   }
-  console.log(table.toString());
-  console.log(source_default.gray(`Total: ${destinations.length} destination(s)`));
 }
 
-// src/cli/commands/show.ts
-async function showCommand(uuid) {
-  const coolify = getCoolifyService();
-  const initResult = await coolify.init();
-  if (isErr(initResult)) {
-    console.error(source_default.red(`Error: ${initResult.error.message}`));
+// src/cli/commands/diagnose.ts
+async function diagnoseAppCommand(query) {
+  const resolved = query || resolveUuid(undefined);
+  if (!resolved) {
+    console.error(source_default.red("Error: No app name/UUID provided and no .coolify.json found"));
     return;
   }
-  const result = await coolify.listApplications();
-  if (isErr(result)) {
-    console.error(source_default.red(`Error: ${result.error.message}`));
-    return;
+  console.log(source_default.cyan(`Diagnosing application: ${resolved}...
+`));
+  try {
+    const { application, recentDeployments, envVarCount, recentLogs, issues } = await getCliSdk().diagnose.app(resolved);
+    console.log(source_default.bold("Application:"));
+    console.log(`  ${source_default.gray("Name:")}   ${application.name}`);
+    console.log(`  ${source_default.gray("UUID:")}   ${application.uuid}`);
+    console.log(`  ${source_default.gray("Status:")} ${formatStatus(application.status)}`);
+    console.log(`  ${source_default.gray("FQDN:")}   ${application.fqdn || "none"}`);
+    console.log(`  ${source_default.gray("Env vars:")} ${envVarCount}`);
+    if (recentDeployments.length > 0) {
+      console.log(source_default.bold(`
+Recent Deployments:`));
+      for (const d of recentDeployments) {
+        const status = d.status?.includes("failed") ? source_default.red(d.status) : source_default.green(d.status);
+        console.log(`  ${source_default.gray(d.uuid.slice(0, 12))} ${status} ${source_default.gray(new Date(d.created_at).toLocaleString())}`);
+      }
+    }
+    if (recentLogs.length > 0) {
+      console.log(source_default.bold(`
+Recent Logs (last 5):`));
+      for (const line of recentLogs.slice(-5)) {
+        console.log(`  ${source_default.gray(line)}`);
+      }
+    }
+    if (issues.length > 0) {
+      console.log(source_default.bold.red(`
+Issues (${issues.length}):`));
+      for (const issue of issues) {
+        console.log(`  ${source_default.red("!")} ${issue}`);
+      }
+    } else {
+      console.log(source_default.bold.green(`
+No issues detected`));
+    }
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
   }
-  const apps = result.value;
-  const app = apps.find((a) => a.uuid === uuid || a.uuid.startsWith(uuid));
-  if (!app) {
-    console.error(source_default.red(`Application not found: ${uuid}`));
-    return;
+}
+async function diagnoseServerCommand(query) {
+  console.log(source_default.cyan(`Diagnosing server: ${query}...
+`));
+  try {
+    const { server, resources, domains, issues } = await getCliSdk().diagnose.server(query);
+    console.log(source_default.bold("Server:"));
+    console.log(`  ${source_default.gray("Name:")}      ${server.name}`);
+    console.log(`  ${source_default.gray("UUID:")}      ${server.uuid}`);
+    console.log(`  ${source_default.gray("IP:")}        ${server.ip || "-"}`);
+    console.log(`  ${source_default.gray("Reachable:")} ${server.is_reachable ? source_default.green("Yes") : source_default.red("No")}`);
+    console.log(`  ${source_default.gray("Resources:")} ${resources.length}`);
+    console.log(`  ${source_default.gray("Domains:")}   ${domains.length}`);
+    if (issues.length > 0) {
+      console.log(source_default.bold.red(`
+Issues (${issues.length}):`));
+      for (const issue of issues) {
+        console.log(`  ${source_default.red("!")} ${issue}`);
+      }
+    } else {
+      console.log(source_default.bold.green(`
+No issues detected`));
+    }
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
   }
-  console.log(source_default.cyan("Application Details:"));
-  console.log("");
-  console.log(source_default.gray("UUID:       ") + source_default.white(app.uuid));
-  console.log(source_default.gray("Name:       ") + source_default.white(app.name));
-  console.log(source_default.gray("Status:     ") + source_default.white(app.status));
-  console.log(source_default.gray("Description:") + source_default.white(app.description || "N/A"));
-  console.log(source_default.gray("Repository: ") + source_default.white(app.git_repository || "N/A"));
-  console.log(source_default.gray("Branch:     ") + source_default.white(app.git_branch || "N/A"));
-  console.log(source_default.gray("Build Pack: ") + source_default.white(app.build_pack || "N/A"));
-  console.log(source_default.gray("Ports:      ") + source_default.white(app.ports_exposes || "N/A"));
-  console.log(source_default.gray("FQDN:       ") + source_default.white(app.fqdn || "N/A"));
-  console.log(source_default.gray("Dockerfile: ") + source_default.white(app.dockerfile_location || "N/A"));
-  console.log(source_default.gray("Base Dir:   ") + source_default.white(app.base_directory || "N/A"));
-  console.log("");
-  console.log(source_default.cyan("Destination:"));
-  if (app.destination) {
-    console.log(source_default.gray("  UUID:  ") + source_default.white(app.destination.uuid));
-    console.log(source_default.gray("  Name:  ") + source_default.white(app.destination.name));
-    if (app.destination.server) {
-      console.log(source_default.gray("  Server:") + source_default.white(` ${app.destination.server.name} (${app.destination.server.ip})`));
+}
+async function scanIssuesCommand() {
+  console.log(source_default.cyan(`Scanning infrastructure...
+`));
+  try {
+    const { totalServers, totalApps, totalDatabases, totalServices, issues } = await getCliSdk().diagnose.infrastructure();
+    console.log(source_default.bold("Infrastructure Summary:"));
+    console.log(`  ${source_default.gray("Servers:")}    ${totalServers}`);
+    console.log(`  ${source_default.gray("Apps:")}       ${totalApps}`);
+    console.log(`  ${source_default.gray("Databases:")}  ${totalDatabases}`);
+    console.log(`  ${source_default.gray("Services:")}   ${totalServices}`);
+    if (issues.length > 0) {
+      console.log(source_default.bold.red(`
+Issues (${issues.length}):`));
+      for (const issue of issues) {
+        console.log(`  ${source_default.red("!")} [${issue.type}] ${issue.resource} (${issue.uuid}): ${issue.message}`);
+      }
+    } else {
+      console.log(source_default.bold.green(`
+No issues detected across all infrastructure`));
     }
-  } else {
-    console.log(source_default.yellow("  No destination configured"));
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
   }
-  console.log("");
-  console.log(source_default.cyan("Commands:"));
-  if (app.install_command)
-    console.log(source_default.gray("  Install: ") + source_default.white(app.install_command));
-  if (app.build_command)
-    console.log(source_default.gray("  Build:   ") + source_default.white(app.build_command));
-  if (app.start_command)
-    console.log(source_default.gray("  Start:   ") + source_default.white(app.start_command));
 }
 
-// src/cli/commands/deployments.ts
-var import_cli_table36 = __toESM(require_table(), 1);
-async function deploymentsCommand(uuid, options = {}) {
-  const coolify = getCoolifyService();
-  const initResult = await coolify.init();
-  if (isErr(initResult)) {
-    console.error(source_default.red(`Error: ${initResult.error.message}`));
+// src/cli/commands/exec.ts
+async function execCommand(uuid, command) {
+  const resolved = resolveUuid(uuid);
+  if (!resolved) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
     return;
   }
-  const result = await coolify.getApplicationDeploymentHistory(uuid);
-  if (isErr(result)) {
-    console.error(source_default.red(`Error: ${result.error.message}`));
-    return;
+  console.log(source_default.gray(`Executing on ${resolved}: ${command}`));
+  try {
+    const result = await getCliSdk().applications.exec(resolved, command);
+    if (result.response) {
+      console.log(result.response);
+    } else if (result.message) {
+      console.log(source_default.green(result.message));
+    }
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
   }
-  let deployments = result.value;
-  deployments = deployments.reverse();
-  if (options.limit) {
-    deployments = deployments.slice(0, options.limit);
+}
+
+// src/cli/commands/active-deployments.ts
+var activeDeploymentsCommand = () => runList("active deployment(s)", (s) => s.deployments.active(), [
+  { header: "UUID", value: (d) => d.uuid },
+  { header: "Status", value: (d) => formatStatus(d.status) },
+  { header: "Commit", value: (d) => d.commit?.slice(0, 7) || "-" },
+  {
+    header: "Created",
+    value: (d) => new Date(d.created_at).toLocaleString()
   }
-  if (deployments.length === 0) {
-    console.log(source_default.yellow("No deployments found"));
+]);
+
+// src/cli/commands/network.ts
+async function networkInspectCommand(uuid, options = {}) {
+  const resolved = resolveUuid(uuid);
+  if (!resolved) {
+    console.error(source_default.red("Error: No UUID provided and no .coolify.json found"));
     return;
   }
-  const table = new import_cli_table36.default({
-    head: [
-      source_default.cyan("ID"),
-      source_default.cyan("UUID"),
-      source_default.cyan("Status"),
-      source_default.cyan("Commit"),
-      source_default.cyan("Created")
-    ],
-    ...options.full ? { colWidths: [8, 36, 20, 10, 20] } : {}
-  });
-  for (const dep of deployments) {
-    table.push([
-      String(dep.id),
-      options.full ? dep.uuid : dep.uuid.slice(0, 8),
-      formatStatus(dep.status),
-      dep.commit?.slice(0, 7) || "-",
-      new Date(dep.created_at).toLocaleString()
-    ]);
+  const servicesToTest = options.services ? options.services.split(",").map((s) => s.trim()) : [];
+  console.log(source_default.cyan(`Inspecting network for ${resolved}...
+`));
+  try {
+    const info = await getCliSdk().network.inspect(resolved, servicesToTest);
+    console.log(source_default.bold("Container Hosts (/etc/hosts):"));
+    if (info.hosts.length > 0) {
+      for (const h of info.hosts) {
+        console.log(`  ${source_default.gray(h)}`);
+      }
+    } else {
+      console.log(source_default.yellow("  No entries"));
+    }
+    if (info.interfaces.length > 0) {
+      console.log(source_default.bold(`
+Network Interfaces:`));
+      for (const iface of info.interfaces) {
+        console.log(`  ${source_default.gray(iface.trim())}`);
+      }
+    }
+    const envEntries = Object.entries(info.networkEnv);
+    if (envEntries.length > 0) {
+      console.log(source_default.bold(`
+Network Environment Variables:`));
+      for (const [key, val] of envEntries) {
+        console.log(`  ${source_default.green(key)} = ${source_default.gray(val)}`);
+      }
+    }
+    if (info.dns.length > 0) {
+      console.log(source_default.bold(`
+DNS Resolution:`));
+      for (const d of info.dns) {
+        const status = d.resolved ? source_default.green(`✓ ${d.ip}`) : source_default.red("✗ FAILED");
+        console.log(`  ${source_default.white(d.hostname)} → ${status}`);
+      }
+    }
+    if (info.connectivity.length > 0) {
+      console.log(source_default.bold(`
+Service Connectivity:`));
+      for (const c of info.connectivity) {
+        const status = c.reachable ? source_default.green(`✓ reachable (${c.responseTime}ms)`) : source_default.red("✗ unreachable");
+        console.log(`  ${source_default.white(c.target)} → ${status}`);
+      }
+    }
+    console.log(source_default.bold(`
+Trace:`));
+    for (const step of info.trace.steps) {
+      console.log(`  ${source_default.gray(step.step)} ${source_default.yellow(step.durationMs + "ms")}${step.detail ? source_default.gray(` (${step.detail})`) : ""}`);
+    }
+    console.log(source_default.gray(`  Total: ${info.trace.totalMs}ms`));
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+async function analyzeDeployCommand(deploymentUuid) {
+  console.log(source_default.cyan(`Analyzing deployment ${deploymentUuid}...
+`));
+  try {
+    const analysis = await getCliSdk().diagnose.deployFailure(deploymentUuid);
+    console.log(source_default.bold("Deployment:"));
+    console.log(`  ${source_default.gray("UUID:")}     ${analysis.deploymentUuid}`);
+    console.log(`  ${source_default.gray("Status:")}   ${analysis.status}`);
+    console.log(`  ${source_default.gray("Category:")} ${source_default.yellow(analysis.category)}`);
+    console.log(source_default.bold.red(`
+Diagnosis: ${analysis.summary}`));
+    console.log(source_default.cyan(`Suggestion: ${analysis.suggestion}`));
+    if (analysis.errors.length > 0) {
+      console.log(source_default.bold(`
+Error Lines (${analysis.errors.length}):`));
+      for (const line of analysis.errors.slice(0, 10)) {
+        console.log(`  ${source_default.red(line.trim())}`);
+      }
+      if (analysis.errors.length > 10) {
+        console.log(source_default.gray(`  ... and ${analysis.errors.length - 10} more`));
+      }
+    }
+    console.log(source_default.bold(`
+Trace:`));
+    for (const step of analysis.trace.steps) {
+      console.log(`  ${source_default.gray(step.step)} ${source_default.yellow(step.durationMs + "ms")}${step.detail ? source_default.gray(` (${step.detail})`) : ""}`);
+    }
+  } catch (error) {
+    console.error(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
   }
-  console.log(table.toString());
-  console.log(source_default.gray(`Total: ${deployments.length} deployment(s)`));
 }
 
 // src/cli/index.ts
@@ -12388,26 +14568,77 @@ var program2 = new Command;
 program2.name("coolify-mcp").description("CLI for Coolify deployment management").version("0.1.0");
 program2.command("create").description("Create a new application").option("--name <name>", "Application name").option("--description <desc>", "Application description").option("--server <uuid>", "Server UUID").option("--project <uuid>", "Project UUID").option("--environment <uuid>", "Environment UUID (auto-fetched if not provided)").option("--repo <url>", "Git repository URL").option("--branch <branch>", "Git branch", "main").option("--type <type>", "Application type (public, private-github-app, private-deploy-key, dockerfile, docker-image, docker-compose)", "public").option("--build-pack <pack>", "Build pack (dockerfile, nixpacks, static, dockercompose)", "dockerfile").option("--ports <ports>", "Ports to expose (default: 3000)", "3000").option("--docker-image <image>", "Docker image (for docker-image type)").option("--docker-compose <content>", "Docker Compose content (for docker-compose type)").option("--docker-compose-location <path>", 'Docker Compose file path (for dockercompose buildPack, e.g., "docker-compose.yml")').option("--dockerfile-location <path>", 'Dockerfile location (e.g., "apps/haidodocs/Dockerfile")').option("--base-directory <dir>", 'Base directory for build context (default: "/")', "/").action(createCommand2);
 program2.command("config").description("Manage configuration").argument("[action]", "Action to perform (set, get, path)").option("--key <key>", 'Configuration key (for "set" action)').option("--value <value>", 'Configuration value (for "set" action)').action(configCommand);
-program2.command("list").description("List all applications").option("-t, --team <id>", "Filter by team ID").option("-p, --project <id>", "Filter by project ID").option("--full", "Show full UUIDs instead of truncated").action(listCommand);
-program2.command("deploy <uuid>").description("Deploy an application").option("-f, --force", "Force rebuild without cache").option("-t, --tag <tag>", "Deploy specific tag/version").action(deployCommand);
-program2.command("logs <uuid>").description("Get application logs").option("-n, --lines <number>", "Number of lines to retrieve", "50").option("-f, --follow", "Follow logs in real-time").action((uuid, options) => {
+program2.command("list").description("List all applications").option("-t, --team <id>", "Filter by team ID").option("-p, --project <id>", "Filter by project ID").action(listCommand);
+program2.command("deploy [uuid]").description("Deploy an application (reads .coolify.json if no UUID)").option("-f, --force", "Force rebuild without cache").option("-t, --tag <tag>", "Deploy specific tag/version").action(deployCommand);
+program2.command("logs [uuid]").description("Get application logs (reads .coolify.json if no UUID)").option("-n, --lines <number>", "Number of lines to retrieve", "50").option("-f, --follow", "Follow logs in real-time").action((uuid, options) => {
   const lines = parseInt(options.lines, 10);
   logsCommand(uuid, { lines, follow: options.follow });
 });
-program2.command("servers").description("List available servers").option("--full", "Show full UUIDs instead of truncated").action((options) => serversCommand(options));
-program2.command("projects").description("List or create projects").option("--full", "Show full UUIDs instead of truncated").option("--create <name>", "Create a new project with this name").option("--description <desc>", "Project description (use with --create)").action((options) => projectsCommand(options));
-program2.command("environments <projectUuid>").description("List environments for a project").option("--full", "Show full UUIDs instead of truncated").action((projectUuid, options) => environmentsCommand(projectUuid, options));
-program2.command("env <uuid>").description("Manage environment variables for an application").option("--set <KEY=VALUE>", "Set an environment variable").option("--delete <KEY>", "Delete an environment variable").option("--buildtime", "Mark variable as build-time only (use with --set)").action((uuid, options) => envCommand(uuid, options));
-program2.command("update <uuid>").description("Update an application configuration").option("--name <name>", "Application name").option("--description <desc>", "Application description").option("--build-pack <pack>", "Build pack (dockerfile, nixpacks, static)").option("--git-branch <branch>", "Git branch").option("--ports <ports>", "Ports to expose (e.g., 3000)").option("--install-command <cmd>", "Install command (nixpacks)").option("--build-command <cmd>", "Build command").option("--start-command <cmd>", "Start command").option("--dockerfile-location <path>", 'Dockerfile location (e.g., "apps/haidodocs/Dockerfile")').option("--base-directory <dir>", 'Base directory for build context (e.g., "/")').option("--domains <domains>", 'Domains (comma-separated with protocol, e.g., "https://app.example.com")').option("--auto-deploy", "Enable auto-deploy on git push").option("--no-auto-deploy", "Disable auto-deploy on git push").option("--force-https", "Enable forced HTTPS redirect").action((uuid, options) => updateCommand({ uuid, ...options }));
-program2.command("delete <uuid>").description("Delete an application").option("-f, --force", "Skip confirmation prompt").option("-y, --yes", "Skip confirmation prompt (alias for --force)").action((uuid, options) => deleteCommand(uuid, options));
+program2.command("servers").description("List available servers").action((options) => serversCommand(options));
+program2.command("projects").description("List or create projects").option("--create <name>", "Create a new project with this name").option("--description <desc>", "Project description (use with --create)").action((options) => projectsCommand(options));
+program2.command("environments <projectUuid>").description("List environments for a project").action((projectUuid, options) => environmentsCommand(projectUuid, options));
+program2.command("env [uuid]").description("Manage env vars (reads .coolify.json if no UUID)").option("--set <KEY=VALUE>", "Set an environment variable").option("--delete <KEY>", "Delete an environment variable").option("--buildtime", "Mark variable as build-time only (use with --set)").action((uuid, options) => envCommand(uuid, options));
+program2.command("update [uuid]").description("Update app config (reads .coolify.json if no UUID)").option("--name <name>", "Application name").option("--description <desc>", "Application description").option("--build-pack <pack>", "Build pack (dockerfile, nixpacks, static)").option("--git-branch <branch>", "Git branch").option("--ports <ports>", "Ports to expose (e.g., 3000)").option("--install-command <cmd>", "Install command (nixpacks)").option("--build-command <cmd>", "Build command").option("--start-command <cmd>", "Start command").option("--dockerfile-location <path>", 'Dockerfile location (e.g., "apps/haidodocs/Dockerfile")').option("--base-directory <dir>", 'Base directory for build context (e.g., "/")').option("--domains <domains>", 'Domains (comma-separated with protocol, e.g., "https://app.example.com")').option("--auto-deploy", "Enable auto-deploy on git push").option("--no-auto-deploy", "Disable auto-deploy on git push").option("--force-https", "Enable forced HTTPS redirect").action((uuid, options) => updateCommand({ uuid, ...options }));
+program2.command("delete [uuid]").description("Delete application (reads .coolify.json if no UUID)").option("-f, --force", "Skip confirmation prompt").option("-y, --yes", "Skip confirmation prompt (alias for --force)").action((uuid, options) => deleteCommand(uuid, options));
 program2.command("destinations <serverUuid>").description("List available destinations for a server").action(destinationsCommand);
-program2.command("show <uuid>").description("Show detailed information about an application").action(showCommand);
-program2.command("deployments <uuid>").description("Show deployment history for an application").option("--full", "Show full UUIDs").option("-n, --limit <number>", "Limit number of deployments shown", "10").action((uuid, options) => {
+program2.command("show [uuid]").description("Show app details (reads .coolify.json if no UUID)").action(showCommand);
+program2.command("deployments [uuid]").description("Show deployment history (reads .coolify.json if no UUID)").option("-n, --limit <number>", "Limit number of deployments shown", "10").action((uuid, options) => {
   const limit = parseInt(options.limit, 10);
   deploymentsCommand(uuid, { full: options.full, limit });
 });
+program2.command("start [uuid]").description("Start application (reads .coolify.json if no UUID)").action(startCommand);
+program2.command("stop [uuid]").description("Stop application (reads .coolify.json if no UUID)").action(stopCommand);
+program2.command("restart [uuid]").description("Restart application (reads .coolify.json if no UUID)").action(restartCommand);
+program2.command("build-logs <deployment-uuid>").description("View build/deployment logs for a specific deployment").option("-n, --lines <number>", "Number of lines to show (tail)").action((deploymentUuid, options) => {
+  const lines = options.lines ? parseInt(options.lines, 10) : undefined;
+  buildLogsCommand(deploymentUuid, { lines });
+});
+program2.command("service-logs <uuid> <service-name>").description("View logs for a specific docker-compose service").option("-n, --lines <number>", "Number of lines to retrieve", "50").action((uuid, serviceName, options) => {
+  const lines = parseInt(options.lines, 10);
+  serviceLogsCommand(uuid, serviceName, { lines });
+});
+program2.command("version").description("Show Coolify server version").action(versionCommand);
+program2.command("databases").description("List all databases").action((options) => databasesCommand(options));
+program2.command("services").description("List all services").action((options) => servicesCommand(options));
+program2.command("cancel-deploy <deployment-uuid>").description("Cancel an in-progress deployment").action(cancelDeployCommand);
+program2.command("server-resources <server-uuid>").description("List resources deployed on a server").action((serverUuid, options) => serverResourcesCommand(serverUuid, options));
+var db = program2.command("db").description("Manage databases");
+db.command("list").description("List all databases").action(dbListCommand);
+db.command("get <uuid>").description("Get database details").action(dbGetCommand);
+db.command("start <uuid>").description("Start a database").action(dbStartCommand);
+db.command("stop <uuid>").description("Stop a database").action(dbStopCommand);
+db.command("restart <uuid>").description("Restart a database").action(dbRestartCommand);
+db.command("delete <uuid>").description("Delete a database").action(dbDeleteCommand);
+db.action(() => db.help());
+var svc = program2.command("svc").description("Manage services");
+svc.command("list").description("List all services").action(svcListCommand);
+svc.command("get <uuid>").description("Get service details").action(svcGetCommand);
+svc.command("start <uuid>").description("Start a service").action(svcStartCommand);
+svc.command("stop <uuid>").description("Stop a service").action(svcStopCommand);
+svc.command("restart <uuid>").description("Restart a service").action(svcRestartCommand);
+svc.command("delete <uuid>").description("Delete a service").action(svcDeleteCommand);
+svc.action(() => svc.help());
+var keys = program2.command("keys").description("Manage SSH private keys");
+keys.command("list").description("List all private keys").action(keysListCommand);
+keys.command("get <uuid>").description("Get private key details").action(keysGetCommand);
+keys.command("delete <uuid>").description("Delete a private key").action(keysDeleteCommand);
+keys.action(() => keys.help());
+var team = program2.command("team").description("Manage teams");
+team.command("list").description("List all teams").action(teamsListCommand);
+team.command("current").description("Show current team").action(teamsCurrentCommand);
+team.command("members <team-id>").description("Show team members").action(teamsMembersCommand);
+team.action(() => team.help());
+program2.command("diagnose [query]").description("Diagnose application (reads .coolify.json if no query)").action(diagnoseAppCommand);
+program2.command("diagnose-server <query>").description("Diagnose a server (name, IP, or UUID)").action(diagnoseServerCommand);
+program2.command("scan").description("Scan all infrastructure for issues").action(scanIssuesCommand);
+program2.command("exec [uuid] <command>").description("Execute command on app container (reads .coolify.json)").action(execCommand);
+program2.command("active-deployments").description("List all active/queued deployments").action(activeDeploymentsCommand);
+var net = program2.command("network").description("Network diagnostics");
+net.command("inspect [uuid]").description("Inspect container network (DNS, hosts, connectivity)").option("--services <names>", "Comma-separated service names to test (e.g., db,redis)").action((uuid, options) => networkInspectCommand(uuid, options));
+net.action(() => net.help());
+program2.command("analyze-deploy <deployment-uuid>").description("Analyze a failed deployment (extract errors, suggest fixes)").action(analyzeDeployCommand);
 program2.action(() => {
-  console.log(source_default.cyan("Coolify MCP CLI"));
+  console.log(source_default.cyan("Coolify MCP CLI v0.6.0"));
   console.log(source_default.gray(`Manage Coolify deployments from the command line
 `));
   program2.help();