kubiy-paas-cli 0.1.19 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubiy-paas-cli",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "CLI para la plataforma PaaS de Kubiy",
   "main": "index.js",
   "bin": {
@@ -23,5 +23,8 @@
   "files": [
     "index.js",
     "src"
-  ]
+  ],
+  "dependencies": {
+    "tar": "^7.4.3"
+  }
 }

package/src/commands/deploy.js

@@ -1,9 +1,9 @@
 // src/commands/deploy.js
-const { execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
 const https = require("https");
+const tar = require("tar");
 const { apiPost } = require("../api");
 const { logInfo, logSuccess, logError } = require("../logger");
 
@@ -95,12 +95,58 @@ function loadKubiyIgnore(projectRoot) {
   }
 }
 
+/**
+ * Convertir un patrón estilo glob simple (con `*` y `?`) a RegExp.
+ * Solo soporta `*` (cualquier secuencia sin `/`) y `?` (un caracter sin `/`).
+ */
+function globToRegex(pattern) {
+  const escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, "[^/]*")
+    .replace(/\?/g, "[^/]");
+  return new RegExp(`^${escaped}$`);
+}
+
+/**
+ * Normalizar patrones de exclusión: quitar ./ inicial y / final.
+ */
+function normalizeExcludePattern(pattern) {
+  let normalized = pattern.trim();
+  if (normalized.startsWith("./")) normalized = normalized.substring(2);
+  if (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+  return normalized;
+}
+
+/**
+ * Construir filtro para la API de `tar` a partir de la lista de patrones.
+ * Aplica la regla "si cualquier segmento del path coincide, se excluye",
+ * equivalente al comportamiento de `tar --exclude=` con nombres de carpetas
+ * o archivos a cualquier profundidad.
+ */
+function buildExcludeFilter(patterns) {
+  const regexes = patterns
+    .map(normalizeExcludePattern)
+    .filter(Boolean)
+    .map(globToRegex);
+
+  return function shouldInclude(filePath /* , stat */) {
+    const normalized = filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (!normalized) return true;
+    const segments = normalized.split("/").filter(Boolean);
+    for (const re of regexes) {
+      if (segments.some((seg) => re.test(seg))) return false;
+    }
+    return true;
+  };
+}
+
 /**
  * Empaquetar código en .tar.gz
  * - Se genera en el directorio temporal del sistema (NO dentro del repo)
  * - Usa .kubiyignore para excluir archivos y carpetas
+ * - No depende de ningún binario del SO: usa el paquete `tar` de npm
  */
-function createTarball(deployType) {
+async function createTarball(deployType) {
   const projectRoot = process.cwd();
   // Si deployType es "server", usar nombre fijo deploy.tar.gz, sino usar timestamp
   const archiveName = deployType === "server" ? "deploy.tar.gz" : `deploy-${Date.now()}.tar.gz`;
@@ -108,43 +154,22 @@ function createTarball(deployType) {
 
   logInfo("Empaquetando código en " + archiveName + " ...");
 
-  // Cargar patrones de exclusión desde .kubiyignore
   const excludes = loadKubiyIgnore(projectRoot);
-  
-  // Construir argumentos de exclusión para tar
-  // Normalizar patrones: remover ./ inicial, agregar ./ si no tiene
-  const excludeArgs = excludes.map((pattern) => {
-    let normalized = pattern.trim();
-    // Remover ./ inicial si existe
-    if (normalized.startsWith("./")) {
-      normalized = normalized.substring(2);
-    }
-    // Remover / final si existe (carpetas)
-    if (normalized.endsWith("/")) {
-      normalized = normalized.slice(0, -1);
-    }
-    return `--exclude=./${normalized}`;
-  });
-
-  const tarArgs = [
-    "-czf",
-    `"${archivePath}"`,
-    ...excludeArgs,
-    ".",
-  ];
+  const filter = buildExcludeFilter(excludes);
 
   try {
-    execSync(`tar ${tarArgs.join(" ")}`, {
-      cwd: projectRoot,
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf8",
-    });
-  } catch (err) {
-    const stderr = err.stderr ? String(err.stderr) : "";
-    throw new Error(
-      "Error al crear el .tar.gz (¿tienes 'tar' instalado?).\n" +
-        (stderr || err.message)
+    await tar.c(
+      {
+        gzip: true,
+        file: archivePath,
+        cwd: projectRoot,
+        portable: true,
+        filter,
+      },
+      ["."]
     );
+  } catch (err) {
+    throw new Error("Error al crear el .tar.gz: " + (err.message || String(err)));
   }
 
   logSuccess("Artefacto generado en temp: " + archivePath);
@@ -155,32 +180,27 @@ function createTarball(deployType) {
  * Empaquetar directorio static en .tar.gz
  * - Se genera en el directorio temporal del sistema
  * - Empaqueta el contenido del directorio directamente (sin la carpeta contenedora)
+ * - No depende de ningún binario del SO: usa el paquete `tar` de npm
  */
-function createStaticTarball(staticDir) {
+async function createStaticTarball(staticDir) {
   const archiveName = `static-deploy-${Date.now()}.tar.gz`;
   const archivePath = path.join(os.tmpdir(), archiveName);
 
   logInfo(`Empaquetando directorio static: ${staticDir} en ${archiveName}...`);
 
-  // Cambiar al directorio static y empaquetar su contenido directamente
-  const tarArgs = [
-    "-czf",
-    `"${archivePath}"`,
-    "-C",
-    `"${staticDir}"`,
-    ".",
-  ];
-
   try {
-    execSync(`tar ${tarArgs.join(" ")}`, {
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf8",
-    });
+    await tar.c(
+      {
+        gzip: true,
+        file: archivePath,
+        cwd: staticDir,
+        portable: true,
+      },
+      ["."]
+    );
   } catch (err) {
-    const stderr = err.stderr ? String(err.stderr) : "";
     throw new Error(
-      "Error al crear el .tar.gz del directorio static (¿tienes 'tar' instalado?).\n" +
-        (stderr || err.message)
+      "Error al crear el .tar.gz del directorio static: " + (err.message || String(err))
     );
   }
 
@@ -424,9 +444,9 @@ async function run(args = []) {
       
       logInfo(`Usando directorio static: ${outDir}`);
       assertStaticBuild(outDir);
-      archivePath = createStaticTarball(outDir);
+      archivePath = await createStaticTarball(outDir);
     } else {
-      archivePath = createTarball(deployType);
+      archivePath = await createTarball(deployType);
     }
 
     // 5) Pedir presigned URL a la API Kubiy
@@ -451,7 +471,7 @@ async function run(args = []) {
       }
     });
 
-    logInfo(JSON.stringify(presignResp, null, 2));
+    //logInfo(JSON.stringify(presignResp, null, 2));
     const { deployId, releaseId } = presignResp || {};
     if (!deployId || !releaseId) {
       throw new Error(
@@ -477,23 +497,30 @@ async function run(args = []) {
     logSuccess("Artefacto subido correctamente a S3.");
 
     // 7) Avisar a Kubiy que inicie el deploy (POST /deploys)
-    logInfo("Notificando a Kubiy que inicie el deploy...");
-
-    const deployResp = await apiPost("/deploys", {
-      deployId,
-      appId,
-      serviceId,
-      artifactKey: key,
-      commit,
-      env: environment?.name
-    }, {
-      headers: {
-        "x-kubiy-token": apikey
-      }
-    });
-
-    logSuccess("🚀 Deploy iniciado correctamente en Kubiy.");
-    console.log(JSON.stringify(deployResp, null, 2));
+    // En deploys static no se llama a /deploys: la subida del artefacto al
+    // bucket presignado es suficiente para que el backend publique el sitio.
+    if (opts.static) {
+      logSuccess("🚀 Deploy static publicado correctamente en Kubiy.");
+      logInfo(`deployId=${deployId} releaseId=${releaseId}`);
+    } else {
+      logInfo("Notificando a Kubiy que inicie el deploy...");
+
+      const deployResp = await apiPost("/deploys", {
+        deployId,
+        appId,
+        serviceId,
+        artifactKey: key,
+        commit,
+        env: environment?.name
+      }, {
+        headers: {
+          "x-kubiy-token": apikey
+        }
+      });
+
+      logSuccess("🚀 Deploy iniciado correctamente en Kubiy.");
+      console.log(JSON.stringify(deployResp, null, 2));
+    }
 
     logInfo(`Puedes consultar el servicio con: kubiy service:get ${serviceId}`);
     logInfo(`Y los logs con: kubiy logs ${serviceId} --kind=deploy --lines=200`);