kubiy-paas-cli 0.1.21 → 0.1.26

package/src/commands/deploy.js

@@ -1,544 +0,0 @@
-// src/commands/deploy.js
-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");
-
-/**
- * Helpers para .kubiy.json
- */
-
-function loadProjectKubiyConfig() {
-  const projectRoot = process.cwd();
-  const configPath = path.join(projectRoot, ".kubiy.json");
-
-  if (!fs.existsSync(configPath)) {
-    throw new Error(
-      "No se encontró .kubiy.json en este proyecto.\n" +
-        "Ejecuta primero: kubiy link <serviceId>"
-    );
-  }
-
-  const raw = fs.readFileSync(configPath, "utf8");
-  let json;
-  try {
-    json = JSON.parse(raw);
-  } catch (err) {
-    throw new Error(`.kubiy.json inválido: ${err.message}`);
-  }
-
-  const { appId, serviceId, environment, apikey } = json;
-  var healthPath = json.healthPath || "";
-
-  if (!appId || !serviceId) {
-    throw new Error(
-      ".kubiy.json incompleto. Debe tener: appId y serviceId.\n" +
-        JSON.stringify(json, null, 2)
-    );
-  }
-
-  return { 
-    appId, 
-    serviceId, 
-    environment, 
-    healthPath, 
-    apikey,
-    configPath,
-    config: json // Retornar el objeto completo para poder guardarlo después
-  };
-}
-
-function saveProjectKubiyConfig(configPath, config) {
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-}
-
-/**
- * Leer y parsear archivo .kubiyignore
- * Retorna array de patrones a excluir
- */
-function loadKubiyIgnore(projectRoot) {
-  const ignorePath = path.join(projectRoot, ".kubiyignore");
-  const defaultExcludes = [
-    "node_modules",
-    ".git",
-    ".env",
-    ".DS_Store",
-    "*.tar",
-    "*.tar.gz",
-    "bin",
-    "obj",
-    "__pycache__",
-    "*.pyc",
-    "vendor",
-  ];
-
-  if (!fs.existsSync(ignorePath)) {
-    return defaultExcludes;
-  }
-
-  try {
-    const content = fs.readFileSync(ignorePath, "utf8");
-    const lines = content
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .filter((line) => line && !line.startsWith("#")); // Ignorar líneas vacías y comentarios
-
-    // Combinar con exclusiones por defecto y eliminar duplicados
-    const allExcludes = [...new Set([...defaultExcludes, ...lines])];
-    return allExcludes;
-  } catch (err) {
-    logInfo(`No se pudo leer .kubiyignore: ${err.message}. Usando exclusiones por defecto.`);
-    return defaultExcludes;
-  }
-}
-
-/**
- * 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
- */
-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`;
-  const archivePath = path.join(os.tmpdir(), archiveName);
-
-  logInfo("Empaquetando código en " + archiveName + " ...");
-
-  const excludes = loadKubiyIgnore(projectRoot);
-  const filter = buildExcludeFilter(excludes);
-
-  try {
-    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);
-  return archivePath;
-}
-
-/**
- * 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
- */
-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}...`);
-
-  try {
-    await tar.c(
-      {
-        gzip: true,
-        file: archivePath,
-        cwd: staticDir,
-        portable: true,
-      },
-      ["."]
-    );
-  } catch (err) {
-    throw new Error(
-      "Error al crear el .tar.gz del directorio static: " + (err.message || String(err))
-    );
-  }
-
-  logSuccess("Artefacto static generado en temp: " + archivePath);
-  return archivePath;
-}
-
-/**
- * Subir marker JSON a S3 con presigned URL (PUT)
- */
-function uploadMarker(markerUploadUrl, deployId, releaseId) {
-  return new Promise((resolve, reject) => {
-    logInfo('markerUploadUrl: ' + markerUploadUrl);
-    const url = new URL(markerUploadUrl);
-    logInfo('url: ' + JSON.stringify(url));
-    const marker = {
-      deployId,
-      releaseId,
-      createdAt: new Date().toISOString(),
-    };
-
-    const payload = JSON.stringify(marker);
-    const options = {
-      method: "PUT",
-      hostname: url.hostname,
-      port: url.port || 443,
-      path: url.pathname + url.search,
-      headers: {
-        "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(payload),
-      },
-    };
-    logInfo('options: ' + JSON.stringify(options));
-
-    const req = https.request(options, (res) => {
-      if (res.statusCode >= 200 && res.statusCode < 300) {
-        resolve();
-      } else {
-        let data = "";
-        res.on("data", (chunk) => (data += chunk));
-        res.on("end", () => {
-          reject(
-            new Error(
-              `Marker upload failed: HTTP ${res.statusCode} ${res.statusMessage} - ${data}`
-            )
-          );
-        });
-      }
-    });
-
-    req.on("error", reject);
-    req.write(payload);
-    req.end();
-  });
-}
-
-/**
- * Subir archivo a S3 con presigned URL (PUT)
- */
-function uploadFileWithPresignedUrl(urlString, filePath) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(urlString);
-
-    // Leer tamaño del archivo para evitar Transfer-Encoding: chunked
-    let stat;
-    try {
-      stat = fs.statSync(filePath);
-    } catch (err) {
-      return reject(new Error(`No se pudo leer el archivo a subir: ${err.message}`));
-    }
-
-    const fileStream = fs.createReadStream(filePath);
-    fileStream.on("error", reject);
-
-    const options = {
-      method: "PUT",
-      hostname: url.hostname,
-      port: url.port || 443,
-      path: url.pathname + url.search,
-      headers: {
-        "Content-Type": "application/octet-stream",
-        "Content-Length": stat.size,
-      },
-    };
-
-    const req = https.request(options, (res) => {
-      if (res.statusCode >= 200 && res.statusCode < 300) {
-        resolve();
-      } else {
-        let data = "";
-        res.on("data", (chunk) => (data += chunk));
-        res.on("end", () => {
-          reject(
-            new Error(
-              `Error al subir a S3: HTTP ${res.statusCode} ${res.statusMessage} - ${data}`
-            )
-          );
-        });
-      }
-    });
-
-    req.on("error", reject);
-
-    fileStream.pipe(req);
-  });
-}
-
-/**
- * Seleccionar directorio de salida para deploy static
- */
-function pickStaticOutDir(projectDir, overrideDir) {
-  if (overrideDir) {
-    const p = path.resolve(projectDir, overrideDir);
-    if (!fs.existsSync(p)) {
-      throw new Error(`Output dir not found: ${overrideDir}`);
-    }
-    return p;
-  }
-
-  const candidates = ["dist", "build", "out", path.join(".output", "public")];
-  for (const c of candidates) {
-    const p = path.resolve(projectDir, c);
-    if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
-      return p;
-    }
-  }
-
-  throw new Error(
-    `No static output folder found. Expected one of: dist/, build/, out/, .output/public/. ` +
-    `Run your build first or specify --dir <folder>.`
-  );
-}
-
-/**
- * Verificar que el build static tenga index.html
- */
-function assertStaticBuild(outDir) {
-  const indexPath = path.join(outDir, "index.html");
-  if (!fs.existsSync(indexPath)) {
-    throw new Error(`index.html not found in ${outDir}. Did you run the build?`);
-  }
-}
-
-/**
- * Parsear argumentos del comando deploy
- */
-function parseArgs(args) {
-  const opts = {
-    static: false,
-    dir: null,
-    message: null,
-  };
-
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (a === "--static") {
-      opts.static = true;
-    } else if (a === "--dir" && i + 1 < args.length) {
-      opts.dir = args[i + 1];
-      i++;
-    } else if (a.startsWith("--dir=")) {
-      opts.dir = a.split("=")[1];
-    } else if (a === "--message" && i + 1 < args.length) {
-      opts.message = args[i + 1];
-      i++;
-    } else if (a.startsWith("--message=")) {
-      opts.message = a.slice("--message=".length);
-    } else if ((a === "-m") && i + 1 < args.length) {
-      opts.message = args[i + 1];
-      i++;
-    }
-  }
-
-  return opts;
-}
-
-/**
- * Comando principal: kubiy deploy
- * Empaqueta el código y lo sube a S3
- */
-
-async function run(args = []) {
-  let archivePath = null;
-
-  try {
-    const opts = parseArgs(args);
-
-    // 3) Cargar config del proyecto (.kubiy.json)
-    const kubiyConfig = loadProjectKubiyConfig();
-    const { appId, serviceId, environment, healthPath, apikey, configPath, config } = kubiyConfig;
-
-    // La autenticación se hace con el apikey de .kubiy.json (generado por `kubiy link`),
-    // no con el CLI token. Si falta el apikey, hay que re-linkear el proyecto.
-    if (!apikey) {
-      logError("No se encontró 'apikey' en .kubiy.json. Vuelve a linkear el proyecto:");
-      logError("  kubiy link <appId> --apikey=<tu-api-key>");
-      process.exit(1);
-    }
-
-    // Validar que deployType coincida con el modo de deploy
-    const deployType = config.deployType;
-    if (!opts.static && deployType === "static") {
-      logError("Error: El proyecto está configurado como 'static' en .kubiy.json (deployType: static).");
-      logError("Para hacer deploy de este proyecto, usa: kubiy deploy --static");
-      process.exit(1);
-    }
-    if (opts.static && deployType && deployType !== "static") {
-      logError(`Error: El proyecto está configurado con deployType: '${deployType}' en .kubiy.json, pero estás intentando hacer deploy static.`);
-      logError("Para hacer deploy de este proyecto, usa: kubiy deploy (sin --static)");
-      process.exit(1);
-    }
-
-    // Mensaje obligatorio que identifica el deploy (se envía como commit)
-    const commit = (opts.message && opts.message.trim()) ? opts.message.trim() : null;
-    if (!commit) {
-      logError("Debes indicar un mensaje que identifique este deploy.");
-      logError("Uso: kubiy deploy --message \"Descripción del deploy\"");
-      logError("  o: kubiy deploy -m \"Descripción del deploy\"");
-      logError("  o: kubiy deploy --message=Descripción");
-      process.exit(1);
-    }
-    
-    // 4) Crear tarball (en temp)
-    if (opts.static) {
-      const projectRoot = process.cwd();
-      
-      // Prioridad: 1) --dir del CLI, 2) static.outDir del config, 3) autodetección
-      const cliDir = opts.dir;
-      const configOutDir = config.static?.outDir || null;
-      
-      const outDir = pickStaticOutDir(projectRoot, cliDir || configOutDir);
-      
-      // Si se detectó automáticamente y no está en el config, guardarlo
-      if (!configOutDir && !cliDir) {
-        config.static = config.static || {};
-        const relativeOutDir = path.relative(projectRoot, outDir).replace(/\\/g, "/");
-        config.static.outDir = relativeOutDir;
-        saveProjectKubiyConfig(configPath, config);
-        logInfo(`Detected output dir: ${config.static.outDir} (saved)`);
-      }
-      
-      logInfo(`Usando directorio static: ${outDir}`);
-      assertStaticBuild(outDir);
-      archivePath = await createStaticTarball(outDir);
-    } else {
-      archivePath = await createTarball(deployType);
-    }
-
-    // 5) Pedir presigned URL a la API Kubiy
-    logInfo("Solicitando presigned URL a Kubiy...");
-
-    const presignBody = {
-      appId,
-      serviceId,
-      commit,
-      env: environment?.name,
-      healthPath: healthPath
-    };
-
-    // Si es static, agregar el parámetro static al body
-    if (opts.static) {
-      presignBody.static = true;
-    }
-
-    const presignResp = await apiPost("/deploys/presign", presignBody, {
-      headers: {
-        "x-kubiy-token": apikey
-      }
-    });
-
-    //logInfo(JSON.stringify(presignResp, null, 2));
-    const { deployId, releaseId } = presignResp || {};
-    if (!deployId || !releaseId) {
-      throw new Error(
-        "Respuesta de /deploys/presign incompleta. Falta deployId o releaseId.\n" +
-          JSON.stringify(presignResp, null, 2)
-      );
-    }
-
-    let key = presignResp?.key;
-    let uploadUrl = presignResp?.uploadUrl;
-    if (!key || !uploadUrl) {
-      throw new Error(
-        "Respuesta de /deploys/presign incompleta. Falta key o uploadUrl.\n" +
-          JSON.stringify(presignResp, null, 2)
-      );
-    }
-   
-    logSuccess(`Presign OK. deployId=${deployId} releaseId=${releaseId}`);
-
-    // 6) Subir a S3 usando uploadUrl si no es static
-    logInfo("Subiendo artefacto a S3...");
-    await uploadFileWithPresignedUrl(uploadUrl, archivePath);
-    logSuccess("Artefacto subido correctamente a S3.");
-
-    // 7) Avisar a Kubiy que inicie el deploy (POST /deploys)
-    // 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`);
-  } catch (err) {
-    logError("Error en kubiy deploy:");
-    logError(err.message || err);
-    process.exit(1);
-  } finally {
-    // 8) Limpiar el artefacto local en temp
-    if (archivePath && fs.existsSync(archivePath)) {
-      try {
-        fs.unlinkSync(archivePath);
-        logInfo(`Artefacto temporal eliminado: ${archivePath}`);
-      } catch (e) {
-        logError(`No se pudo eliminar artefacto temporal: ${archivePath} (${e.message})`);
-      }
-    }
-  }
-}
-
-module.exports = { run };

package/src/commands/login.js

@@ -1,16 +0,0 @@
-const { setCliToken } = require("../config");
-const { logSuccess, logError } = require("../logger");
-
-async function run(args) {
-  const token = args[0];
-
-  if (!token) {
-    logError("Uso: kubiy login <cliToken>");
-    process.exit(1);
-  }
-
-  setCliToken(token.trim());
-  logSuccess("CLI token guardado en ~/.kubiy/config.json");
-}
-
-module.exports = { run };

package/src/commands/logs.js

@@ -1,112 +0,0 @@
-// src/commands/logs.js
-const fs = require("fs");
-const path = require("path");
-const { apiGet } = require("../api");
-const { logInfo, logError } = require("../logger");
-
-function parseArgs(args) {
-  const opts = {
-    kind: "app",
-    lines: 200,
-  };
-  const clean = [];
-
-  for (const a of args) {
-    if (a.startsWith("--kind=")) {
-      opts.kind = a.split("=")[1] || "app";
-    } else if (a.startsWith("--lines=")) {
-      const v = parseInt(a.split("=")[1] || "200", 10);
-      if (!isNaN(v) && v > 0) opts.lines = v;
-    } else {
-      clean.push(a);
-    }
-  }
-
-  // clean[0] puede o no tener serviceId
-  return { serviceId: clean[0] || null, opts };
-}
-
-function loadKubiyLink() {
-  const filepath = path.join(process.cwd(), ".kubiy.json");
-
-  if (!fs.existsSync(filepath)) {
-    return null;
-  }
-
-  try {
-    const raw = fs.readFileSync(filepath, "utf8");
-    const cfg = JSON.parse(raw);
-
-    return { serviceId: cfg.serviceId || null, apikey: cfg.apikey || null };
-  } catch (err) {
-    // Si el json está roto, que el usuario se entere
-    logError("No se pudo leer .kubiy.json:", err.message || String(err));
-    return null;
-  }
-}
-
-async function run(args) {
-  const { serviceId: cliServiceId, opts } = parseArgs(args);
-
-  const linked = loadKubiyLink();
-  let serviceId = cliServiceId;
-  const apikey = linked && linked.apikey;
-
-  // 🍀 Si no viene serviceId por CLI, intentamos usar el del link
-  if (!serviceId) {
-    const linkedServiceId = linked && linked.serviceId;
-    if (!linkedServiceId) {
-      logError(
-        "Uso: kubiy logs <serviceId> --kind=deploy|app --lines=200\n" +
-          "O bien, ejecuta primero: kubiy link <serviceId> y luego solo 'kubiy logs'."
-      );
-      process.exit(1);
-    }
-    serviceId = linkedServiceId;
-    logInfo(`Usando serviceId del link (.kubiy.json): ${serviceId}`);
-  }
-
-  if (!apikey) {
-    logError("No se encontró 'apikey' en .kubiy.json. Vuelve a linkear el proyecto:");
-    logError("  kubiy link <appId> --apikey=<tu-api-key>");
-    process.exit(1);
-  }
-
-  const kind = (opts.kind || "app").toLowerCase();
-  const lines = opts.lines || 200;
-
-  try {
-    logInfo(
-      `Obteniendo logs (${kind}) del servicio ${serviceId} (últimas ${lines} líneas)...`
-    );
-
-    const qs = new URLSearchParams({
-      kind,
-      lines: String(lines),
-    }).toString();
-
-    const pathUrl = `/services/${encodeURIComponent(serviceId)}/logs?${qs}`;
-
-    const resp = await apiGet(pathUrl, {
-      headers: { "x-kubiy-token": apikey },
-    }); // { stdout, stderr, ... }
-    const stdout = resp.stdout || "";
-    const stderr = resp.stderr || "";
-
-    if (stdout) {
-      process.stdout.write(stdout.endsWith("\n") ? stdout : stdout + "\n");
-    }
-
-    // Si quieres mostrar stderr como comentario abajo:
-    if (stderr) {
-      console.error("\n[STDERR]");
-      process.stderr.write(stderr.endsWith("\n") ? stderr : stderr + "\n");
-    }
-  } catch (err) {
-    logError("Error al obtener logs:");
-    logError(err.message || String(err));
-    process.exit(1);
-  }
-}
-
-module.exports = { run };