kubiy-paas-cli 0.1.0 → 0.1.1

package/fix-link.js

@@ -4,47 +4,69 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-// Ruta donde npm instala los comandos globales
-const npmBinPath = path.join(os.homedir(), 'AppData', 'Roaming', 'npm');
-const kubiyCmdPath = path.join(npmBinPath, 'kubiy.cmd');
-const kubiyPs1Path = path.join(npmBinPath, 'kubiy.ps1');
-
-// Corregir kubiy.cmd
-if (fs.existsSync(kubiyCmdPath)) {
-  let content = fs.readFileSync(kubiyCmdPath, 'utf8');
-  
-  // Verificar si necesita corrección (no tiene 'node' explícito)
-  if (!content.includes('node "%dp0%')) {
-    // Reemplazar la línea que ejecuta el .js directamente
-    content = content.replace(
-      /"%dp0%\\node_modules\\kubiy-paas-cli\\index\.js"/g,
-      'node "%dp0%\\node_modules\\kubiy-paas-cli\\index.js"'
-    );
-    
-    fs.writeFileSync(kubiyCmdPath, content, 'utf8');
-    console.log('✅ Archivo kubiy.cmd corregido');
+const isWin = process.platform === 'win32';
+
+if (isWin) {
+  // ==========================
+  // LADO WINDOWS (lo que ya tenías)
+  // ==========================
+
+  // Ruta donde npm instala los comandos globales (típico en Windows)
+  const npmBinPath = path.join(os.homedir(), 'AppData', 'Roaming', 'npm');
+  const kubiyCmdPath = path.join(npmBinPath, 'kubiy.cmd');
+  const kubiyPs1Path = path.join(npmBinPath, 'kubiy.ps1');
+
+  // Corregir kubiy.cmd
+  if (fs.existsSync(kubiyCmdPath)) {
+    let content = fs.readFileSync(kubiyCmdPath, 'utf8');
+
+    // Verificar si necesita corrección (no tiene 'node' explícito)
+    if (!content.includes('node "%dp0%')) {
+      // Reemplazar la línea que ejecuta el .js directamente
+      content = content.replace(
+        /"%dp0%\\node_modules\\kubiy-paas-cli\\index\.js"/g,
+        'node "%dp0%\\node_modules\\kubiy-paas-cli\\index.js"'
+      );
+
+      fs.writeFileSync(kubiyCmdPath, content, 'utf8');
+      console.log('✅ Archivo kubiy.cmd corregido');
+    }
   }
-}
 
-// Corregir kubiy.ps1
-if (fs.existsSync(kubiyPs1Path)) {
-  let content = fs.readFileSync(kubiyPs1Path, 'utf8');
-  
-  // Verificar si necesita corrección (no tiene 'node' explícito)
-  if (!content.includes('node "$basedir')) {
-    // Reemplazar las líneas que ejecutan el .js directamente
-    content = content.replace(
-      /& "`$basedir\/node_modules\/kubiy-paas-cli\/index\.js"/g,
-      '& node "$basedir/node_modules/kubiy-paas-cli/index.js"'
-    );
-    // También corregir la versión sin backticks
-    content = content.replace(
-      /& "\$basedir\/node_modules\/kubiy-paas-cli\/index\.js"/g,
-      '& node "$basedir/node_modules/kubiy-paas-cli/index.js"'
-    );
-    
-    fs.writeFileSync(kubiyPs1Path, content, 'utf8');
-    console.log('✅ Archivo kubiy.ps1 corregido');
+  // Corregir kubiy.ps1
+  if (fs.existsSync(kubiyPs1Path)) {
+    let content = fs.readFileSync(kubiyPs1Path, 'utf8');
+
+    // Verificar si necesita corrección (no tiene 'node' explícito)
+    if (!content.includes('node "$basedir')) {
+      // Reemplazar las líneas que ejecutan el .js directamente
+      content = content.replace(
+        /& "`\$basedir\/node_modules\/kubiy-paas-cli\/index\.js"/g,
+        '& node "$basedir/node_modules/kubiy-paas-cli/index.js"'
+      );
+      // También corregir la versión sin backticks (por si acaso)
+      content = content.replace(
+        /& "\$basedir\/node_modules\/kubiy-paas-cli\/index\.js"/g,
+        '& node "$basedir/node_modules/kubiy-paas-cli/index.js"'
+      );
+
+      fs.writeFileSync(kubiyPs1Path, content, 'utf8');
+      console.log('✅ Archivo kubiy.ps1 corregido');
+    }
   }
-}
 
+} else {
+  // ==========================
+  // LADO UNIX / MAC
+  // ==========================
+  try {
+    const indexPath = path.join(__dirname, 'index.js');
+
+    if (fs.existsSync(indexPath)) {
+      fs.chmodSync(indexPath, 0o755);
+      console.log('✅ Unix: permisos ejecutables aplicados a index.js (chmod +x)');
+    }
+  } catch (e) {
+    console.log('⚠ No se pudo aplicar chmod a index.js en Unix:', e.message);
+  }
+}

package/index.js

@@ -1,77 +1,55 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
-// CLI minimalista
-const fs = require("fs");
-const os = require("os");
 const path = require("path");
+const { logInfo, logError } = require("./src/logger");
 
-const args = process.argv.slice(2); // [command, ...rest]
+const args = process.argv.slice(2);
+const command = args[0];
 
-const CONFIG_DIR = path.join(os.homedir(), ".kubiy");
-const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-
-function ensureConfigDir() {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-}
-
-function readConfig() {
-  if (!fs.existsSync(CONFIG_FILE)) return {};
-  const raw = fs.readFileSync(CONFIG_FILE, "utf8");
-  return JSON.parse(raw);
-}
-
-function writeConfig(obj) {
-  ensureConfigDir();
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(obj, null, 2), "utf8");
-}
-
-async function cmdLogin() {
-  // Versión simple: aceptamos token por argumento
-  // kubiy login <token>
-  const token = args[1];
-  if (!token) {
-    console.error("Uso: kubiy login <cliToken>");
+async function main() {
+  try {
+    switch (command) {
+      case "login":
+        await require("./src/commands/login").run(args.slice(1));
+        break;
+      case "whoami":
+        await require("./src/commands/whoami").run(args.slice(1));
+        break;
+      case "service:get":
+        await require("./src/commands/service-get").run(args.slice(1));
+        break;
+      case "git:connect":
+        await require("./src/commands/git-connect").run(args.slice(1));
+        break;
+      case "deploy":
+        await require("./src/commands/deploy").run();
+        break;
+      case "version":
+      case "--version":
+      case "-v":
+        await require("./src/commands/version").run(args.slice(1));
+        break;
+      default:
+        printHelp();
+        process.exit(0);
+    }
+  } catch (err) {
+    logError("Error en CLI:", err.message || err);
     process.exit(1);
   }
-
-  const cfg = readConfig();
-  cfg.cliToken = token.trim();
-  writeConfig(cfg);
-
-  console.log("✅ CLI token guardado en ~/.kubiy/config.json");
-}
-
-async function cmdWhoami() {
-  const cfg = readConfig();
-  if (!cfg.cliToken) {
-    console.log("No hay token configurado. Ejecuta: kubiy login <cliToken>");
-    return;
-  }
-  console.log("CLI configurado. Token (truncado):", cfg.cliToken.slice(0, 6) + "****");
 }
 
-async function main() {
-  const command = args[0];
-
-  switch (command) {
-    case "login":
-      await cmdLogin();
-      break;
-    case "whoami":
-      await cmdWhoami();
-      break;
-    default:
-      console.log("Kubiy PaaS CLI");
-      console.log("Uso:");
-      console.log("  kubiy login <cliToken>");
-      console.log("  kubiy whoami");
-      process.exit(0);
-  }
+function printHelp() {
+  logInfo("Kubiy PaaS CLI");
+  console.log("");
+  console.log("Uso:");
+  console.log("  kubiy login <cliToken>");
+  console.log("  kubiy whoami");
+  console.log("  kubiy service:get <serviceId>");
+  console.log("  kubiy git:connect <serviceId>");
+  console.log("  kubiy deploy");
+  console.log("  kubiy version");
+  console.log("");
 }
 
-main().catch((err) => {
-  console.error("Error en CLI:", err);
-  process.exit(1);
-});
+main();

package/package.json

@@ -1,15 +1,13 @@
 {
   "name": "kubiy-paas-cli",
-  "version": "0.1.0",
-  "description": "CLI para desplegar apps en la plataforma PaaS de Kubiy",
+  "version": "0.1.1",
+  "description": "CLI para la plataforma PaaS de Kubiy",
   "main": "index.js",
   "bin": {
     "kubiy": "index.js"
   },
-  "preferGlobal": true,
   "scripts": {
-    "start": "node index.js",
-    "postinstall": "node fix-link.js"
+    "start": "node index.js"
   },
   "keywords": [
     "kubiy",
@@ -17,9 +15,10 @@
     "cli",
     "deploy"
   ],
-  "author": "Elfego Guerra",
+  "author": "Kubiy",
   "license": "MIT",
   "engines": {
     "node": ">=12.0.0"
   }
 }
+

package/src/api.js

@@ -0,0 +1,79 @@
+const https = require("https");
+const { getCliToken } = require("./config");
+const { logError } = require("./logger");
+
+// Ajusta esta URL a tu API real
+const API_BASE = process.env.KUBIY_API_BASE || "https://i5c812hwh2.execute-api.us-east-1.amazonaws.com";
+
+function request(method, path, body, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const token = opts.token || getCliToken();
+    const url = new URL(path, API_BASE);
+
+    const headers = {
+      "Accept": "application/json"
+    };
+
+    let payload = null;
+    if (body) {
+      payload = JSON.stringify(body);
+      headers["Content-Type"] = "application/json";
+      headers["Content-Length"] = Buffer.byteLength(payload);
+    }
+
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+
+    const options = {
+      method,
+      headers
+    };
+
+    const req = https.request(url, options, (res) => {
+      let data = "";
+
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        if (!data) {
+          return resolve(null);
+        }
+
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            resolve(data);
+          }
+        } else {
+          reject(
+            new Error(
+              `API ${res.statusCode}: ${data || res.statusMessage || "Error"}`
+            )
+          );
+        }
+      });
+    });
+
+    req.on("error", reject);
+
+    if (payload) {
+      req.write(payload);
+    }
+    req.end();
+  });
+}
+
+function apiGet(path, opts) {
+  return request("GET", path, null, opts);
+}
+
+function apiPost(path, body, opts) {
+  return request("POST", path, body, opts);
+}
+
+module.exports = {
+  apiGet,
+  apiPost,
+  API_BASE
+};

package/src/commands/deploy.js

@@ -0,0 +1,167 @@
+// src/commands/deploy.js
+const { execSync } = require("child_process");
+const fs = require("fs");
+const { logInfo, logSuccess, logError } = require("../logger");
+
+function runGit(command, options = {}) {
+  const full = `git ${command}`;
+  try {
+    return execSync(full, {
+      stdio: ["pipe", "pipe", "inherit"],
+      ...options,
+    }).toString().trim();
+  } catch (err) {
+    throw new Error(`Error al ejecutar: ${full}\n${err.message}`);
+  }
+}
+
+function isGitRepo() {
+  try {
+    runGit("rev-parse --is-inside-work-tree");
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+function ensureGitRepo() {
+  if (isGitRepo()) {
+    return;
+  }
+
+  logInfo("Este directorio no es un repositorio git. Inicializando...");
+  runGit("init");
+
+  // Intentar crear master como rama inicial
+  try {
+    runGit("checkout -b master");
+  } catch (_) {
+    // Si falla, probablemente ya haya HEAD en detached; no pasa nada por ahora.
+  }
+
+  logSuccess("Repositorio git inicializado y rama master creada (si fue posible).");
+}
+
+function getCurrentBranch() {
+  try {
+    return runGit("rev-parse --abbrev-ref HEAD");
+  } catch (_) {
+    return null;
+  }
+}
+
+function branchExists(branchName) {
+  try {
+    const out = runGit(`branch --list ${branchName}`);
+    return out !== "";
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Normaliza para que la rama activa sea master.
+ *
+ * Casos:
+ * - Si ya estamos en master → OK.
+ * - Si existe master → hacemos checkout master.
+ * - Si NO existe master → renombramos la rama actual a master.
+ */
+function ensureOnMaster() {
+  const current = getCurrentBranch();
+
+  if (!current) {
+    throw new Error("No se pudo determinar la rama actual.");
+  }
+
+  if (current === "master") {
+    logInfo("Ya estás en la rama master.");
+    return;
+  }
+
+  logInfo(`Rama actual: ${current}`);
+
+  if (branchExists("master")) {
+    logInfo("Encontrada rama master. Cambiando a master...");
+    runGit("checkout master", { stdio: "inherit" });
+    logSuccess("Ahora estás en master.");
+  } else {
+    logInfo(`No existe rama master. Renombrando rama actual '${current}' a 'master'...`);
+    runGit(`branch -m master`, { stdio: "inherit" });
+    logSuccess("Rama actual renombrada a master.");
+  }
+}
+
+function ensureKubiyRemote() {
+  try {
+    const url = runGit("remote get-url kubiy");
+    logInfo(`Remote 'kubiy' encontrado: ${url}`);
+  } catch (_) {
+    throw new Error(
+      "No se encontró el remote 'kubiy'.\n" +
+        "Asegúrate de haber ejecutado antes: kubiy git:connect <serviceId>"
+    );
+  }
+}
+
+function hasChangesToCommit() {
+  const status = runGit("status --porcelain");
+  return status !== "";
+}
+
+function createAutoCommit() {
+  const msg = `kubiy deploy - ${new Date().toISOString()}`;
+  logInfo("Creando commit automático...");
+
+  runGit("add .", { stdio: "inherit" });
+  try {
+    runGit(`commit -m "${msg}"`, { stdio: "inherit" });
+    logSuccess(`Commit creado: ${msg}`);
+  } catch (err) {
+    // Si no hay nada que commitear, git commit truena. Lo detectamos.
+    if (String(err.message).includes("nothing to commit")) {
+      logInfo("No hay cambios nuevos para commitear.");
+    } else {
+      throw err;
+    }
+  }
+}
+
+function pushToKubiy() {
+  logInfo("Haciendo push a 'kubiy' (rama master)...");
+  runGit("push kubiy master", { stdio: "inherit" });
+  logSuccess("Push a kubiy master completado.");
+}
+
+async function run() {
+  try {
+    // 1) Asegurar repo git
+    ensureGitRepo();
+
+    // 2) Asegurar que estamos en master
+    ensureOnMaster();
+
+    // 3) Asegurar remote kubiy
+    ensureKubiyRemote();
+
+    // 4) Crear commit automático si hay cambios
+    if (hasChangesToCommit()) {
+      createAutoCommit();
+    } else {
+      logInfo("No hay cambios locales. Solo se intentará hacer push.");
+    }
+
+    // 5) Push a kubiy master
+    pushToKubiy();
+
+    logSuccess("🚀 Deploy completado. Revisa tu servicio Kubiy.");
+  } catch (err) {
+    logError("Error en kubiy deploy:");
+    logError(err.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  run,
+};

package/src/commands/git-connect.js

@@ -0,0 +1,113 @@
+// src/commands/git-connect.js
+const { getCliToken } = require("../config");
+const { apiGet, apiPost } = require("../api");
+const { ensureSshKey, SSH_PRIV } = require("../ssh");
+const { ensureSshHostConfig } = require("../ssh-config");
+const { addRemote } = require("../git");
+const { logInfo, logSuccess, logError } = require("../logger");
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+
+function ensureGitRepo() {
+  if (fs.existsSync(".git")) return;
+
+  logInfo("Este directorio no es un repositorio git. Inicializando...");
+  execSync("git init", { stdio: "inherit" });
+  try {
+    execSync("git checkout -b main", { stdio: "inherit" });
+  } catch (_) {
+    // Si ya existe main/master, no pasa nada
+  }
+}
+
+function parseRepoUrl(gitRepoUrl) {
+  // Esperamos algo como ssh://deploy@1.2.3.4/home/deploy/app.git
+  try {
+    const url = new URL(gitRepoUrl);
+    return {
+      host: url.hostname,
+      path: url.pathname // /home/deploy/app.git
+    };
+  } catch (e) {
+    // fallback muy básico
+    // ssh://deploy@1.2.3.4/home/deploy/app.git
+    if (!gitRepoUrl.startsWith("ssh://")) {
+      throw new Error(`gitRepoUrl inválido: ${gitRepoUrl}`);
+    }
+    const withoutScheme = gitRepoUrl.slice("ssh://".length);
+    const [userHost, pathPart] = withoutScheme.split("/", 2);
+    const host = userHost.split("@").pop();
+    return {
+      host,
+      path: "/" + pathPart
+    };
+  }
+}
+
+async function run(argv) {
+    const serviceId = argv[0];
+
+    if (!serviceId) {
+        logError("Uso: kubiy git:connect <serviceId>");
+        process.exit(1);
+    }
+
+    const token = getCliToken();
+    if (!token) {
+        logError("No hay CLI token. Ejecuta: kubiy login <cliToken>");
+        process.exit(1);
+    }
+
+    // 1) Asegurar llave SSH local (~/.kubiy/id_ed25519)
+    const pubKey = ensureSshKey();
+
+    // 2) Registrar llave en tu API
+    logInfo("Registrando llave SSH en Kubiy...");
+    await apiPost("/cli/ssh-keys", { publicKey: pubKey });
+    logSuccess("Llave SSH registrada.");
+
+    // 3) Sincronizar llaves con la EC2 del servicio
+    logInfo("Sincronizando llaves SSH con la instancia...");
+    try {
+        const syncResp = await apiPost(`/cli/services/${serviceId}/sync-ssh`, {});
+        logSuccess(
+        `Llaves sincronizadas. keysApplied=${syncResp.keysApplied}, ssmStatus=${syncResp.ssmStatus}`
+        );
+    } catch (e) {
+        logError(`No se pudo sincronizar llaves con la instancia: ${e.message}`);
+        // seguimos, porque igual podrías tener la llave ya metida de antes
+    }
+
+    // 4) Obtener info del servicio (para gitRepoUrl)
+    logInfo("Obteniendo información del servicio...");
+    const service = await apiGet(`/services/${serviceId}`);
+
+    const gitRepoUrl = service.gitRepoUrl;
+    if (!gitRepoUrl) {
+        logError("El servicio no tiene gitRepoUrl todavía. Asegúrate que esté en RUNNING.");
+        process.exit(1);
+    }
+
+    const { host: ec2Host, path: repoPath } = parseRepoUrl(gitRepoUrl);
+
+    // 5) Configurar ~/.ssh/config con un host lógico único para este servicio
+    const hostAlias = `kubiy-${serviceId}`.slice(0, 60); // por si se va muy largo
+
+    ensureSshHostConfig(hostAlias, ec2Host, SSH_PRIV);
+
+    // 6) Configurar remote con el alias, no con la IP directa
+    ensureGitRepo();
+    logInfo("Configurando remote 'kubiy'...");
+    const remoteUrl = `ssh://${hostAlias}${repoPath}`;
+    addRemote("kubiy", remoteUrl);
+
+    logSuccess("Remote 'kubiy' configurado.");
+
+    logSuccess("Listo. Puedes hacer ahora:");
+    console.log("  git add .");
+    console.log("  git commit -m \"tu mensaje\"");
+    console.log("  git push kubiy main   # o master");
+}
+
+module.exports = { run };

package/src/commands/login.js

@@ -0,0 +1,16 @@
+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/service-get.js

@@ -0,0 +1,24 @@
+const { apiGet } = require("../api");
+const { logError, logSuccess } = require("../logger");
+const { getCliToken } = require("../config");
+
+async function run(args) {
+  const serviceId = args[0];
+
+  if (!serviceId) {
+    logError("Uso: kubiy service:get <serviceId>");
+    process.exit(1);
+  }
+
+  const token = getCliToken();
+  if (!token) {
+    logError("No hay CLI token. Ejecuta: kubiy login <cliToken>");
+    process.exit(1);
+  }
+
+  const service = await apiGet(`/services/${serviceId}`);
+  logSuccess("Servicio obtenido:");
+  console.log(JSON.stringify(service, null, 2));
+}
+
+module.exports = { run };

package/src/commands/version.js

@@ -0,0 +1,17 @@
+const { logInfo } = require("../logger");
+const { API_BASE, apiGet } = require("../api");
+const pkg = require("../../package.json");
+
+async function run() {
+  logInfo(`Kubiy CLI version: ${pkg.version}`);
+  logInfo(`API base: ${API_BASE}`);
+
+  try {
+    const status = await apiGet("/status"); // ajusta si no tienes este endpoint
+    console.log("API status:", status);
+  } catch (e) {
+    console.log("No se pudo consultar /status de la API:", e.message);
+  }
+}
+
+module.exports = { run };

package/src/commands/whoami.js

@@ -0,0 +1,15 @@
+const { getCliToken } = require("../config");
+const { logInfo, logWarn } = require("../logger");
+
+async function run() {
+  const token = getCliToken();
+  if (!token) {
+    logWarn("No hay CLI token configurado. Ejecuta: kubiy login <cliToken>");
+    return;
+  }
+
+  logInfo("CLI configurado.");
+  console.log("Token (truncado):", token.slice(0, 6) + "****");
+}
+
+module.exports = { run };

package/src/config.js

@@ -0,0 +1,47 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const CONFIG_DIR = path.join(os.homedir(), ".kubiy");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function readConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) return {};
+    const raw = fs.readFileSync(CONFIG_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch (e) {
+    return {};
+  }
+}
+
+function writeConfig(obj) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(obj, null, 2), "utf8");
+}
+
+function getCliToken() {
+  const cfg = readConfig();
+  return cfg.cliToken;
+}
+
+function setCliToken(token) {
+  const cfg = readConfig();
+  cfg.cliToken = token;
+  writeConfig(cfg);
+}
+
+module.exports = {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  readConfig,
+  writeConfig,
+  getCliToken,
+  setCliToken
+};

package/src/git.js

@@ -0,0 +1,24 @@
+const { execSync } = require("child_process");
+const { logInfo, logSuccess, logWarn } = require("./logger");
+
+function run(cmd) {
+  execSync(cmd, { stdio: "inherit" });
+}
+
+function addRemote(name, url) {
+  try {
+    // quitar si existe
+    execSync(`git remote remove ${name}`, { stdio: "ignore" });
+  } catch (_) {
+    // no pasa nada si no existe
+  }
+
+  logInfo(`Agregando remote '${name}' -> ${url}`);
+  execSync(`git remote add ${name} "${url}"`, { stdio: "inherit" });
+  logSuccess(`Remote '${name}' configurado.`);
+}
+
+module.exports = {
+  run,
+  addRemote
+};

package/src/logger.js

@@ -0,0 +1,31 @@
+const COLORS = {
+    reset: "\x1b[0m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m"
+  };
+  
+  function logInfo(...args) {
+    console.log(COLORS.cyan + "ℹ" + COLORS.reset, ...args);
+  }
+  
+  function logSuccess(...args) {
+    console.log(COLORS.green + "✔" + COLORS.reset, ...args);
+  }
+  
+  function logWarn(...args) {
+    console.log(COLORS.yellow + "⚠" + COLORS.reset, ...args);
+  }
+  
+  function logError(...args) {
+    console.error(COLORS.red + "✖" + COLORS.reset, ...args);
+  }
+  
+  module.exports = {
+    logInfo,
+    logSuccess,
+    logWarn,
+    logError
+  };
+  

package/src/ssh-config.js

@@ -0,0 +1,57 @@
+// src/ssh-config.js
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { logInfo, logSuccess } = require("./logger");
+
+const SSH_DIR = path.join(os.homedir(), ".ssh");
+const SSH_CONFIG = path.join(SSH_DIR, "config");
+
+/**
+ * Asegura que exista una entrada Host en ~/.ssh/config
+ * para usar la llave de Kubiy con ese host.
+ *
+ * hostAlias:  nombre lógico (p. ej. "kubiy-srv-<serviceId>")
+ * hostName:   IP pública o hostname real de la EC2
+ * identityFile: ruta absoluta al id_ed25519 de Kubiy
+ */
+function ensureSshHostConfig(hostAlias, hostName, identityFile) {
+  if (!fs.existsSync(SSH_DIR)) {
+    fs.mkdirSync(SSH_DIR, { recursive: true });
+  }
+
+  let existing = "";
+  if (fs.existsSync(SSH_CONFIG)) {
+    existing = fs.readFileSync(SSH_CONFIG, "utf8");
+    // Si ya hay un bloque para este Host, no duplicamos
+    const already = new RegExp(`^Host\\s+${hostAlias}\\b`, "m").test(existing);
+    if (already) {
+      logInfo(`SSH config ya tiene entrada para Host '${hostAlias}'`);
+      return;
+    }
+  }
+
+  // Convertir backslashes a slashes para que OpenSSH en Windows no se maree
+  const identityPath = identityFile.replace(/\\/g, "/");
+
+  const block = [
+    "",
+    `Host ${hostAlias}`,
+    `    HostName ${hostName}`,
+    `    User deploy`,
+    `    IdentityFile ${identityPath}`,
+    `    IdentitiesOnly yes`,
+    ""
+  ].join("\n");
+
+  const newContent = existing ? `${existing.trimEnd()}\n${block}` : block.trimStart();
+
+  fs.writeFileSync(SSH_CONFIG, newContent, "utf8");
+  logSuccess(`Configurado ~/.ssh/config para Host '${hostAlias}'`);
+}
+
+module.exports = {
+  ensureSshHostConfig,
+  SSH_DIR,
+  SSH_CONFIG
+};

package/src/ssh.js

@@ -0,0 +1,40 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execSync } = require("child_process");
+const { logInfo, logSuccess, logWarn } = require("./logger");
+
+const SSH_DIR = path.join(os.homedir(), ".kubiy");
+const SSH_PRIV = path.join(SSH_DIR, "id_ed25519");
+const SSH_PUB = SSH_PRIV + ".pub";
+
+function ensureSshKey() {
+  if (!fs.existsSync(SSH_DIR)) {
+    fs.mkdirSync(SSH_DIR, { recursive: true });
+  }
+
+  if (!fs.existsSync(SSH_PRIV) || !fs.existsSync(SSH_PUB)) {
+    logInfo("No existe llave SSH de Kubiy, generando una nueva...");
+
+    try {
+      execSync(
+        `ssh-keygen -t ed25519 -f "${SSH_PRIV}" -N "" -C "kubiy-cli"`,
+        { stdio: "inherit" }
+      );
+      logSuccess("Llave SSH generada en ~/.kubiy/");
+    } catch (e) {
+      logWarn("Error generando llave SSH:", e.message);
+      throw e;
+    }
+  }
+
+  const pub = fs.readFileSync(SSH_PUB, "utf8").trim();
+  return pub;
+}
+
+module.exports = {
+  SSH_DIR,
+  SSH_PRIV,
+  SSH_PUB,
+  ensureSshKey
+};