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

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

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

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

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

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

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

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

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

package/dist/utils/format.d.ts

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mks2508/coolify-mks-cli-mcp",
-  "version": "0.6.3",
+  "version": "0.9.0",
   "description": "MCP server and CLI for Coolify deployment management",
   "type": "module",
   "main": "./dist/index.js",
@@ -8,7 +8,8 @@
   "types": "./dist/index.d.ts",
   "bin": {
     "coolify-mcp": "dist/cli/index.js",
-    "coolify-mcp-server": "dist/server/stdio.js"
+    "coolify-mcp-server": "dist/server/stdio.js",
+    "coolify-cli": "dist/cli/index.js"
   },
   "exports": {
     ".": {
@@ -52,16 +53,20 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
+    "@clack/prompts": "^1.2.0",
     "@mks2508/better-logger": "^4.0.0",
     "@mks2508/no-throw": "^0.1.0",
     "@modelcontextprotocol/sdk": "^1.25.2",
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
+    "diff": "^8.0.4",
     "ora": "^8.1.1",
-    "prompts": "^2.4.2"
+    "prompts": "^2.4.2",
+    "shiki": "^4.0.2"
   },
   "devDependencies": {
+    "@types/bun": "^1.3.14",
     "@types/node": "^22.10.5",
     "@types/prompts": "^2.4.9",
     "rolldown": "^1.0.0-beta.58",
@@ -72,5 +77,13 @@
   },
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "jsonSchema": [
+    {
+      "name": ".coolify.json",
+      "description": "Coolify deployment configuration",
+      "fileMatch": [".coolify.json"],
+      "url": "./coolify.json.schema.json"
+    }
+  ]
 }

package/src/cli/actions.ts

@@ -13,6 +13,7 @@ import Table from "cli-table3";
 import { Coolify } from "../sdk.js";
 import { formatStatus } from "../utils/format.js";
 import { resolveUuid } from "./coolify-state.js";
+import { resolveNameOrUuid } from "./name-resolver.js";
 
 /** Singleton SDK instance for CLI (uses env vars / config file). */
 let _sdk: Coolify | null = null;
@@ -42,7 +43,10 @@ export async function runAction(
   callFn: (sdk: Coolify, uuid: string) => Promise<unknown>,
   successMsg: (uuid: string) => string,
 ): Promise<void> {
-  const resolved = resolveUuid(uuid);
+  let resolved = resolveUuid(uuid);
+  if (!resolved && uuid) {
+    resolved = await resolveNameOrUuid(uuid);
+  }
   if (!resolved) {
     console.error(
       chalk.red("Error: No UUID provided and no .coolify.json found"),
@@ -129,7 +133,10 @@ export async function runGet<T>(
   callFn: (sdk: Coolify, uuid: string) => Promise<T>,
   formatFn: (item: T) => void,
 ): Promise<void> {
-  const resolved = resolveUuid(uuid);
+  let resolved = resolveUuid(uuid);
+  if (!resolved && uuid) {
+    resolved = await resolveNameOrUuid(uuid);
+  }
   if (!resolved) {
     console.error(
       chalk.red("Error: No UUID provided and no .coolify.json found"),

package/src/cli/commands/create.ts

@@ -4,10 +4,13 @@
  * @module
  */
 
+import * as p from "@clack/prompts";
 import { isOk, isErr } from "@mks2508/no-throw";
 import ora from "ora";
 import chalk from "chalk";
 import { getCoolifyService } from "../../coolify/index.js";
+import { validatePorts } from "../../utils/format.js";
+import type { ICoolifyGithubApp } from "../../coolify/types.js";
 
 /**
  * Create command options.
@@ -34,6 +37,177 @@ interface ICreateOptions {
   dockerComposeLocation?: string;
   dockerfileLocation?: string;
   baseDirectory?: string;
+  githubAppUuid?: string;
+  privateKeyUuid?: string;
+  domain?: string;
+}
+
+/**
+ * Identifier format accepted by Coolify.
+ *
+ * Coolify uses two ID formats:
+ * - Standard UUID v4 (8-4-4-4-12 hex with dashes)
+ * - Laravel-style 24-char alphanumeric IDs (e.g. `awgcco0k48g4kgw8cckkc808`)
+ *
+ * Both are accepted; we reject only clearly invalid input to fail fast
+ * before hitting the API.
+ */
+const ID_REGEX =
+  /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[a-z0-9]{20,30})$/i;
+
+/**
+ * Valid --type values.
+ */
+const VALID_APP_TYPES = [
+  "public",
+  "private-github-app",
+  "private-deploy-key",
+  "dockerfile",
+  "docker-image",
+  "docker-compose",
+] as const;
+
+/**
+ * Valid --build-pack values.
+ */
+const VALID_BUILD_PACKS = ["nixpacks", "static", "dockerfile", "dockercompose"] as const;
+
+/**
+ * TTY detection — used to guard interactive prompts.
+ */
+const isTTY = process.stdout.isTTY === true;
+
+/**
+ * Validates create command options and exits with code 1 on failure.
+ * Called before any API calls.
+ *
+ * @param options - Create options to validate
+ */
+function validateCreateOptions(options: ICreateOptions): void {
+  // --type validation
+  if (options.type && !VALID_APP_TYPES.includes(options.type)) {
+    console.error(chalk.red(`Invalid --type: '${options.type}'`));
+    console.error(chalk.gray(`  Valid values: ${VALID_APP_TYPES.join(", ")}`));
+    process.exit(1);
+  }
+
+  // --build_pack validation
+  if (options.buildPack && !VALID_BUILD_PACKS.includes(options.buildPack)) {
+    console.error(chalk.red(`Invalid --build-pack: '${options.buildPack}'`));
+    console.error(chalk.gray(`  Valid values: ${VALID_BUILD_PACKS.join(", ")}`));
+    process.exit(1);
+  }
+
+  // Identifier format validations (UUID v4 OR Coolify 24-char ID)
+  const idFields: Array<[string, string]> = [
+    ["--server", options.server],
+    ["--project", options.project],
+    ["--environment", options.environment ?? ""],
+    ["--github-app-uuid", options.githubAppUuid ?? ""],
+  ];
+
+  for (const [flag, value] of idFields) {
+    if (value && !ID_REGEX.test(value)) {
+      console.error(chalk.red(`Invalid ID format for ${flag}: '${value}'`));
+      console.error(
+        chalk.gray(
+          `  Expected: UUID v4 (8-4-4-4-12 hex) or Coolify 24-char ID (e.g. a1b2c3d4-e5f6-7890-abcd-ef1234567890 or awgcco0k48g4kgw8cckkc808)`,
+        ),
+      );
+      process.exit(1);
+    }
+  }
+
+  // Required fields
+  if (!options.name) {
+    console.error(chalk.red("--name is required"));
+    process.exit(1);
+  }
+  if (!options.server) {
+    console.error(chalk.red("--server is required"));
+    process.exit(1);
+  }
+  if (!options.project) {
+    console.error(chalk.red("--project is required"));
+    process.exit(1);
+  }
+}
+
+/**
+ * Prompts the user to select a GitHub App from a list of private apps.
+ * Skips prompt entirely if --github-app-uuid is passed explicitly.
+ *
+ * @param apps - List of GitHub apps (should already be filtered to private)
+ * @param explicitUuid - The --github-app-uuid passed by the user (optional)
+ * @returns The selected app's uuid, or null if cancelled
+ */
+async function promptGithubAppSelection(
+  apps: ICoolifyGithubApp[],
+  explicitUuid?: string,
+): Promise<string | null> {
+  // If --github-app-uuid was passed, validate it exists in the list
+  if (explicitUuid) {
+    const found = apps.find((a) => a.uuid === explicitUuid);
+    if (!found) {
+      console.error(
+        chalk.red(`GitHub App '${explicitUuid}' not found among configured private apps`),
+      );
+      if (apps.length > 0) {
+        console.error(
+          chalk.gray(
+            `  Available: ${apps.map((a) => `${a.name} (${a.uuid})`).join(", ")}`,
+          ),
+        );
+      }
+      process.exit(1);
+    }
+    return explicitUuid;
+  }
+
+  // 0 private apps → loud error
+  if (apps.length === 0) {
+    console.error(
+      chalk.red("No private GitHub Apps found. Cannot create private-github-app deployment."),
+    );
+    console.error(
+      chalk.gray("  Configure a private GitHub App in Coolify: Settings → Sources → GitHub App"),
+    );
+    process.exit(1);
+  }
+
+  // 1 private app → silently use it
+  if (apps.length === 1) {
+    return apps[0].uuid;
+  }
+
+  // 2+ private apps → interactive picker
+  if (!isTTY) {
+    console.error(
+      chalk.red(
+        "Multiple private GitHub Apps found but stdin is not a TTY. " +
+          "Pass --github-app-uuid <uuid> to select one explicitly.",
+      ),
+    );
+    process.exit(1);
+  }
+
+  const choices = apps.map((app) => ({
+    label: app.name,
+    value: app.uuid,
+    hint: app.organization ?? undefined,
+  }));
+
+  const selected = await p.select({
+    message: "Select a GitHub App for this deployment:",
+    options: choices,
+  });
+
+  if (p.isCancel(selected)) {
+    console.error(chalk.yellow("Cancelled."));
+    process.exit(1);
+  }
+
+  return selected as string;
 }
 
 /**
@@ -45,45 +219,145 @@ export async function createCommand(options: ICreateOptions) {
   const spinner = ora("Initializing Coolify connection...").start();
 
   try {
+    // Fail-fast validation before any API calls
+    validateCreateOptions(options);
+
     const coolify = getCoolifyService();
     const initResult = await coolify.init();
 
     if (isErr(initResult)) {
-      spinner.fail(
-        chalk.red(`Failed to initialize: ${initResult.error.message}`),
-      );
-      return;
+      spinner.fail(chalk.red(`Failed to initialize: ${initResult.error.message}`));
+      process.exit(1);
     }
 
-    // Auto-fetch environment UUID if not provided
+    // ── Environment resolution ─────────────────────────────────────────────
     let environmentUuid: string | undefined = options.environment;
+    let environmentName: string | undefined;
 
     if (!environmentUuid) {
       spinner.text = "Fetching project environments...";
-
       const envResult = await coolify.getProjectEnvironments(options.project);
 
-      if (isOk(envResult) && envResult.value.length > 0) {
-        // Use the first environment (usually "production")
+      if (isErr(envResult)) {
+        spinner.fail(
+          chalk.red(`Failed to fetch environments: ${envResult.error.message}`),
+        );
+        process.exit(1);
+      }
+
+      if (envResult.value.length === 0) {
+        spinner.fail(
+          chalk.red("No environments found for project. Specify --environment <uuid>"),
+        );
+        process.exit(1);
+      }
+
+      if (envResult.value.length === 1) {
         environmentUuid = envResult.value[0].uuid;
-        const envName = envResult.value[0].name;
+        environmentName = envResult.value[0].name;
         spinner.info(
-          chalk.cyan(`Using environment: ${envName} (${environmentUuid})`),
+          chalk.cyan(`Using only environment: ${environmentName} (${environmentUuid})`),
         );
       } else {
-        spinner.fail(
-          chalk.red(
-            "No environments found for project. Please specify --environment <uuid>",
-          ),
-        );
-        return;
+        // Interactive environment picker
+        if (!isTTY) {
+          spinner.fail(
+            chalk.red(
+              "No --environment specified and stdin is not a TTY. " +
+                "Pass --environment <uuid> explicitly.",
+            ),
+          );
+          process.exit(1);
+        }
+
+        const choices = envResult.value.map((env) => ({
+          label: env.name,
+          value: env.uuid,
+          hint: env.description || undefined,
+        }));
+
+        const selected = await p.select({
+          message: "Select an environment:",
+          options: choices,
+        });
+
+        if (p.isCancel(selected)) {
+          spinner.stop("Cancelled.");
+          process.exit(1);
+        }
+
+        environmentUuid = selected as string;
+        environmentName = envResult.value.find((e) => e.uuid === environmentUuid)?.name;
+        spinner.info(chalk.cyan(`Selected environment: ${environmentName} (${environmentUuid})`));
+      }
+    } else {
+      // Environment was provided — validate it exists and get its name
+      spinner.text = "Validating environment...";
+      const envResult = await coolify.getProjectEnvironments(options.project);
+      if (isOk(envResult)) {
+        const env = envResult.value.find((e) => e.uuid === environmentUuid);
+        if (env) {
+          environmentName = env.name;
+        } else {
+          spinner.fail(
+            chalk.red(`Environment '${environmentUuid}' not found in project.`) +
+              chalk.gray(
+                `\n  Available: ${envResult.value.map((e) => `${e.name} (${e.uuid})`).join(", ")}`,
+              ),
+          );
+          process.exit(1);
+        }
       }
     }
 
-    // Ensure environmentUuid is defined before creating application
     if (!environmentUuid) {
       spinner.fail(chalk.red("Environment UUID is required"));
-      return;
+      process.exit(1);
+    }
+
+    // ── GitHub App resolution ───────────────────────────────────────────────
+    let appType = options.type || "public";
+    let githubAppUuid = options.githubAppUuid;
+
+    if (!githubAppUuid && (appType === "private-github-app" || !options.type)) {
+      spinner.text = "Detecting GitHub Apps...";
+      const ghAppsResult = await coolify.listGithubAppsAll();
+
+      if (isOk(ghAppsResult)) {
+        // Filter to private (non-public) GitHub Apps only.
+        const privateApps = ghAppsResult.value.filter((app) => !app.is_public);
+
+        githubAppUuid = await promptGithubAppSelection(privateApps, options.githubAppUuid);
+
+        if (githubAppUuid === null) {
+          // Should not reach here — promptGithubAppSelection exits on cancel
+          process.exit(1);
+        }
+
+        appType = "private-github-app";
+        const usedApp = privateApps.find((a) => a.uuid === githubAppUuid);
+        if (usedApp) {
+          spinner.info(
+            chalk.cyan(
+              `Using GitHub App: ${usedApp.name}` +
+                (usedApp.organization ? ` (${usedApp.organization})` : ""),
+            ),
+          );
+        }
+      } else if (appType === "private-github-app") {
+        spinner.fail(
+          chalk.red(`Could not list GitHub Apps: ${ghAppsResult.error.message}`),
+        );
+        process.exit(1);
+      }
+    }
+
+    // ── Port validation ─────────────────────────────────────────────────────
+    const portsStr = options.ports || "3000";
+    const portValidation = validatePorts(portsStr);
+    if (!portValidation.valid) {
+      spinner.fail(chalk.red(`Invalid ports: ${portValidation.error}`));
+      process.exit(1);
     }
 
     spinner.text = "Creating application...";
@@ -94,17 +368,20 @@ export async function createCommand(options: ICreateOptions) {
         description: options.description,
         projectUuid: options.project,
         environmentUuid,
+        environmentName,
         serverUuid: options.server,
-        type: options.type || "public",
+        type: appType,
+        githubAppUuid,
         githubRepoUrl: options.repo,
         branch: options.branch || "main",
         buildPack: options.buildPack || "dockerfile",
-        portsExposes: options.ports || "3000",
+        portsExposes: portsStr,
         dockerImage: options.dockerImage,
         dockerCompose: options.dockerCompose,
         dockerComposeLocation: options.dockerComposeLocation,
         dockerfileLocation: options.dockerfileLocation,
         baseDirectory: options.baseDirectory,
+        privateKeyUuid: options.privateKeyUuid,
       },
       (percent, message) => {
         spinner.text = `${chalk.bold(`[${percent}%]`)} ${message}`;
@@ -112,22 +389,52 @@ export async function createCommand(options: ICreateOptions) {
     );
 
     if (isOk(result)) {
+      const createdUuid = result.value.uuid;
       spinner.succeed(
         chalk.green(
-          `Application created! UUID: ${chalk.cyan(result.value.uuid)}`,
+          `Application created! UUID: ${chalk.cyan(createdUuid)}`,
         ),
       );
+
+      // Set domain via PATCH if --domain was provided
+      if (options.domain && createdUuid) {
+        const domainSpinner = ora("Setting domain...").start();
+        const domainValue = options.domain.startsWith("http")
+          ? options.domain
+          : `https://${options.domain}`;
+
+        const updateResult = await coolify.updateApplication(createdUuid, {
+          domains: domainValue,
+        });
+
+        if (isOk(updateResult)) {
+          domainSpinner.succeed(chalk.green(`Domain set: ${chalk.cyan(domainValue)}`));
+        } else {
+          // Non-fatal — domain setting failed but app was created
+          domainSpinner.fail(
+            chalk.red(`Failed to set domain: ${updateResult.error.message}`),
+          );
+        }
+      }
+
       console.log(`  Name: ${chalk.cyan(options.name)}`);
-      console.log(`  Type: ${chalk.cyan(options.type || "public")}`);
+      console.log(`  Type: ${chalk.cyan(appType)}`);
+      if (options.domain) {
+        const domainValue = options.domain.startsWith("http")
+          ? options.domain
+          : `https://${options.domain}`;
+        console.log(`  Domain: ${chalk.cyan(domainValue)}`);
+      }
       console.log(`  Next steps:`);
       console.log(
-        `    1. Set environment variables: ${chalk.yellow("coolify-mcp env " + result.value.uuid)}`,
+        `    1. Set environment variables: ${chalk.yellow("coolify-mcp env " + createdUuid)}`,
       );
       console.log(
-        `    2. Deploy application: ${chalk.yellow("coolify-mcp deploy " + result.value.uuid)}`,
+        `    2. Deploy application: ${chalk.yellow("coolify-mcp deploy " + createdUuid)}`,
       );
     } else {
       spinner.fail(chalk.red(`Creation failed: ${result.error.message}`));
+      process.exit(1);
     }
   } catch (error) {
     spinner.fail(
@@ -135,5 +442,6 @@ export async function createCommand(options: ICreateOptions) {
         `Error: ${error instanceof Error ? error.message : String(error)}`,
       ),
     );
+    process.exit(1);
   }
 }

package/src/cli/commands/db.ts

@@ -16,6 +16,7 @@ import type {
   ICoolifyDatabase,
   ICoolifyDatabaseBackup,
 } from "../../coolify/types.js";
+import { resolveDbNameOrUuid } from "../name-resolver.js";
 
 /** List all databases. */
 export const dbListCommand = () =>
@@ -110,6 +111,42 @@ export const dbDeleteCommand = (uuid: string) =>
     (u) => `Database deleted: ${u}`,
   );
 
+/**
+ * Update a database configuration.
+ *
+ * @param uuid - Database UUID
+ * @param options - Update options (publicPort, isPublic)
+ */
+export async function dbUpdateCommand(
+  uuidOrName: string,
+  options: { publicPort?: string; isPublic?: boolean },
+): Promise<void> {
+  try {
+    const uuid = await resolveDbNameOrUuid(uuidOrName) ?? uuidOrName;
+    const data: Record<string, unknown> = {};
+
+    if (options.publicPort !== undefined) data.public_port = options.publicPort;
+    if (options.isPublic !== undefined) data.is_public = options.isPublic;
+
+    if (Object.keys(data).length === 0) {
+      console.warn(
+        chalk.yellow("No update options provided. Use --help to see available options."),
+      );
+      return;
+    }
+
+    console.log(chalk.cyan(`Updating database ${chalk.bold(uuid)}...`));
+    await getCliSdk().databases.update(uuid, data);
+    console.log(chalk.green("Database updated successfully"));
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}
+
 /** List backups for a database. */
 export const dbBackupsCommand = (uuid: string) =>
   runList<ICoolifyDatabaseBackup>(

package/src/cli/commands/delete.ts

@@ -10,6 +10,7 @@ import { isErr } from "@mks2508/no-throw";
 import chalk from "chalk";
 import { getCoolifyService } from "../../coolify/index.js";
 import { resolveUuid } from "../coolify-state.js";
+import { resolveAppNameOrUuid } from "../name-resolver.js";
 
 /**
  * Executes the delete command.
@@ -22,10 +23,13 @@ export async function deleteCommand(
   uuid: string | undefined,
   options: { force?: boolean; yes?: boolean } = {},
 ): Promise<void> {
-  const resolvedUuid = resolveUuid(uuid);
+  let resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid && uuid) {
+    resolvedUuid = await resolveAppNameOrUuid(uuid);
+  }
   if (!resolvedUuid) {
     console.error(
-      chalk.red("Error: No UUID provided and no .coolify.json found"),
+      chalk.red("Error: No UUID/name provided and no .coolify.json found"),
     );
     return;
   }