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

package/src/utils/format.ts

@@ -86,6 +86,184 @@ export function formatBytes(bytes: number): string {
   return `${bytes.toFixed(1)} ${units[i]}`;
 }
 
+// ─── Validation ─────────────────────────────────────────────────────────────
+
+/**
+ * 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 function validatePorts(ports: string): {
+  valid: boolean;
+  ports: number[];
+  error?: string;
+} {
+  if (!ports || !ports.trim()) {
+    return { valid: false, ports: [], error: "Port string is empty" };
+  }
+
+  const parts = ports.split(",").map((p) => p.trim());
+  const parsed: number[] = [];
+
+  for (const part of parts) {
+    if (!/^\d+$/.test(part)) {
+      return {
+        valid: false,
+        ports: [],
+        error: `Invalid port "${part}" — must be a number`,
+      };
+    }
+    const num = parseInt(part, 10);
+    if (num < 1 || num > 65535) {
+      return {
+        valid: false,
+        ports: [],
+        error: `Port ${num} out of range (1-65535)`,
+      };
+    }
+    parsed.push(num);
+  }
+
+  const dupes = parsed.filter((p, i) => parsed.indexOf(p) !== i);
+  if (dupes.length > 0) {
+    return {
+      valid: false,
+      ports: parsed,
+      error: `Duplicate port: ${dupes[0]}`,
+    };
+  }
+
+  return { valid: true, ports: parsed };
+}
+
+/**
+ * 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 function parseDockerfileExpose(dockerfilePath: string): number[] {
+  try {
+    const content = require("node:fs").readFileSync(dockerfilePath, "utf-8");
+    const ports: number[] = [];
+    for (const line of content.split("\n")) {
+      const match = line.match(/^\s*EXPOSE\s+(.+)/i);
+      if (match) {
+        for (const token of match[1].split(/\s+/)) {
+          // Handle "3000/tcp", "3000/udp", or just "3000"
+          const portStr = token.split("/")[0].trim();
+          const num = parseInt(portStr, 10);
+          if (!isNaN(num) && num >= 1 && num <= 65535) {
+            ports.push(num);
+          }
+        }
+      }
+    }
+    return [...new Set(ports)];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 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 function validateCoolifyState(state: Record<string, unknown>): {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+} {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  // Detect format
+  const isMultiApp = Array.isArray(state.apps);
+  const isSingleApp = typeof state.appUuid === "string";
+
+  if (!isMultiApp && !isSingleApp) {
+    errors.push(
+      'Invalid format: must have "appUuid" (single-app) or "apps" array (multi-app)',
+    );
+    return { valid: false, errors, warnings };
+  }
+
+  // Common required fields
+  const commonRequired = ["serverUuid", "projectUuid", "environmentUuid"];
+  for (const field of commonRequired) {
+    if (!state[field] || typeof state[field] !== "string") {
+      errors.push(`Missing or invalid required field: ${field}`);
+    }
+  }
+
+  if (isSingleApp) {
+    // Validate single-app specific fields
+    if (
+      state.portsExposes &&
+      typeof state.portsExposes === "string"
+    ) {
+      const portResult = validatePorts(state.portsExposes as string);
+      if (!portResult.valid) {
+        warnings.push(`portsExposes: ${portResult.error}`);
+      }
+    }
+
+    if (state.buildPack && typeof state.buildPack === "string") {
+      const validBuildPacks = [
+        "dockerfile",
+        "nixpacks",
+        "static",
+        "dockercompose",
+      ];
+      if (!validBuildPacks.includes(state.buildPack as string)) {
+        warnings.push(
+          `Unknown buildPack "${state.buildPack}" — expected: ${validBuildPacks.join(", ")}`,
+        );
+      }
+    }
+  }
+
+  if (isMultiApp) {
+    const apps = state.apps as Array<Record<string, unknown>>;
+    if (apps.length === 0) {
+      errors.push("Multi-app format requires at least one app");
+    }
+    for (let i = 0; i < apps.length; i++) {
+      const app = apps[i];
+      if (!app.uuid || typeof app.uuid !== "string") {
+        errors.push(`apps[${i}]: missing or invalid "uuid"`);
+      }
+      if (!app.name || typeof app.name !== "string") {
+        errors.push(`apps[${i}]: missing or invalid "name"`);
+      }
+      if (!app.service || typeof app.service !== "string") {
+        errors.push(`apps[${i}]: missing or invalid "service"`);
+      }
+      if (app.port !== undefined) {
+        const port = app.port as number;
+        if (typeof port !== "number" || port < 1 || port > 65535) {
+          warnings.push(`apps[${i}] (${app.name}): invalid port ${port}`);
+        }
+      }
+    }
+
+    // Check for duplicate UUIDs
+    const uuids = apps.map((a) => a.uuid).filter(Boolean);
+    const dupeUuids = uuids.filter((u, i) => uuids.indexOf(u) !== i);
+    if (dupeUuids.length > 0) {
+      errors.push(`Duplicate app UUIDs: ${dupeUuids.join(", ")}`);
+    }
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
 /**
  * Formats timestamp to relative time.
  *