mgpanel-cli 1.0.4 → 1.0.7

package/bin/mgpanel.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 
 const http = require("http");
+const https = require("https");
 const fs = require("fs");
 const path = require("path");
+const { URL } = require("url");
 
 function printHelp() {
   console.log(`
@@ -18,6 +20,8 @@ Uso:
 
   mgpanel dev [puerto]
 
+  mgpanel publish --account <cuenta> [--token <token>] [--api-url <url>]
+
 Ejemplos:
   mgpanel init miweb
   cd miweb
@@ -28,6 +32,9 @@ Ejemplos:
 
   mgpanel dev
   mgpanel dev 8080
+
+  mgpanel publish --account zzz-eloymanuel --token mi-token
+  mgpanel publish --account zzz-eloymanuel --token mi-token --api-url https://api.mgpanel.com
 `);
 }
 
@@ -106,6 +113,28 @@ console.log("[MGPanel] Global JS loaded");
 `;
   fs.writeFileSync(path.join(projectPath, "index.html"), indexHTML, "utf8");
 
+  // .env: Variables de entorno para publish
+  const envContent = `# MGPanel CLI - Variables de entorno
+# Descomenta y configura estas variables para usar 'mgpanel publish'
+
+# Token de autenticación para publicar (obtén uno desde el panel de MGPanel)
+# MGPANEL_TOKEN=tu-token-aqui
+
+# URL de la API (opcional, por defecto usa https://dev.mgpanel.co)
+# MGPANEL_API_URL=https://dev.mgpanel.co
+`;
+  fs.writeFileSync(path.join(projectPath, ".env"), envContent, "utf8");
+  // Agregar .env al .gitignore si existe
+  const gitignorePath = path.join(projectPath, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    const gitignore = fs.readFileSync(gitignorePath, "utf8");
+    if (!gitignore.includes(".env")) {
+      fs.appendFileSync(gitignorePath, "\n# MGPanel CLI\n.env\n");
+    }
+  } else {
+    fs.writeFileSync(gitignorePath, "# MGPanel CLI\n.env\n", "utf8");
+  }
+
   // dev/preview.js: carga una page leyendo page.json y componiendo módulos
   const previewJS = `async function loadModule(name) {
   const base = \`modules/\${name}/\${name}\`;
@@ -185,6 +214,7 @@ renderPage(pageFromPath()).catch(err => {
     route: "/",
     title: "Home",
     description: "Página principal creada con MGPanel.",
+    directory: "",
     modules: []
   };
   fs.writeFileSync(
@@ -248,10 +278,23 @@ Esto crea:
   "route": "/about",
   "title": "About",
   "description": "Descripción de la página about.",
-  "modules": []
+  "directory": "",
+  "modules": [
+    { "name": "header", "import": false }
+  ]
 }
 \`\`\`
 
+**Campo \`directory\`:**
+- Por defecto viene vacío (\`""\`)
+- Puede editarse manualmente para agregar valores como \`"app/"\` cuando se requiera
+- Se usa en la nube para organizar las páginas en directorios
+
+**Campo \`import\` en módulos:**
+- \`import: false\` - Módulo propio de esta página (se crea la sección completa)
+- \`import: true\` - Módulo importado de otra página (se referencia la sección existente)
+- Se asigna automáticamente al agregar módulos con \`mgpanel add module\`
+
 ### Crear un Módulo
 
 \`\`\`bash
@@ -290,15 +333,20 @@ Esto actualiza el archivo \`pages/<nombre-pagina>/page.json\` añadiendo el mód
   "route": "/",
   "title": "Home",
   "description": "Página principal.",
+  "directory": "",
   "modules": [
-    { "name": "header" },
-    { "name": "hero-banner" },
-    { "name": "footer" }
+    { "name": "header", "import": false },
+    { "name": "hero-banner", "import": false },
+    { "name": "footer", "import": true }
   ]
 }
 \`\`\`
 
-**Importante:** Los módulos se renderizan en el orden en que aparecen en el array \`modules\`.
+**Importante:** 
+- Los módulos se renderizan en el orden en que aparecen en el array \`modules\`.
+- El campo \`import\` se agrega automáticamente:
+  - \`import: false\` si el módulo es propio de esta página (primera vez que se agrega)
+  - \`import: true\` si el módulo pertenece a otra página y se está reutilizando
 
 ### Servidor de Desarrollo
 
@@ -400,6 +448,96 @@ Cuando despliegues el proyecto en MGPanel:
 3. El contenido puede ser editado desde el panel de administración
 4. La estructura de archivos se mantiene compatible
 
+### Importante: compatibilidad Local Preview vs MGPanel (Nube)
+
+En *preview local* (⁠ dev/preview.js ⁠) cada módulo se inserta envuelto en un contenedor como:
+
+\`\`\`html
+<div data-mgpanel-module="header">...contenido del módulo...</div>
+\`\`\`
+
+En *MGPanel (nube)* el CMS puede renderizar el HTML del módulo *sin ese wrapper, y además el HTML puede inyectarse **después** de que el archivo JS del módulo ya fue cargado.
+
+Por eso, en los módulos con JS, sigue estas reglas para que funcionen *tanto local como en nube*:
+
+•⁠  ⁠*Seleccionar root con fallback*:
+  - Primero intenta ⁠ \`document.querySelector('[data-mgpanel-module="<modulo>"]')\` ⁠ (preview).
+  - Si no existe, busca el nodo real del módulo, por ejemplo ⁠ \`.mg-<modulo>\` ⁠ (nube).
+•⁠  ⁠*Inicialización tardía (cloud-safe)*:
+  - No asumas que el HTML existe cuando corre el JS.
+  - Implementa retry + ⁠ \`MutationObserver\` ⁠, y escucha ⁠ \`DOMContentLoaded\` ⁠ / ⁠ \`load\` ⁠.
+•⁠  ⁠*Evitar doble init*:
+  - Marca el nodo root con ⁠ \`dataset\` ⁠ (por ejemplo ⁠ \`data-mg-init="1"\` ⁠) para no registrar listeners dos veces.
+•⁠  ⁠*Rutas de assets*:
+  - En SPAs y en nube, usa rutas absolutas: ⁠ \`src="/assets/Logo.png"\` ⁠ en vez de ⁠ \`assets/Logo.png\` ⁠.
+•⁠  ⁠*No ocultar contenido sin JS*:
+  - Si usas animaciones por clase (ej. ⁠ \`data-mg-animate\` ⁠), asegúrate que el contenido no quede invisible si el JS no corre.
+
+### Campo \`import\` en módulos
+
+Cada módulo en \`page.json\` puede tener un campo \`import\` que indica si el módulo es propio de la página o se está importando de otra:
+
+- **\`import: false\`** - Módulo propio: La primera página donde se agrega un módulo tiene \`import: false\`. En la nube, esto crea una nueva sección completa.
+- **\`import: true\`** - Módulo importado: Si un módulo ya existe en otra página y lo agregas a una nueva página, tendrá \`import: true\`. En la nube, esto referencia la sección existente en lugar de duplicarla.
+
+**Ejemplo:**
+\`\`\`json
+{
+  "modules": [
+    { "name": "header", "import": false },  // Propio de esta página
+    { "name": "banner", "import": false },   // Propio de esta página
+    { "name": "footer", "import": true }     // Importado de otra página
+  ]
+}
+\`\`\`
+
+El campo \`import\` se asigna automáticamente cuando usas \`mgpanel add module\`. La primera página donde agregas un módulo será la "dueña" (\`import: false\`), y las páginas subsecuentes que usen ese módulo tendrán \`import: true\`.
+
+#### Plantilla recomendada para JS de módulos (cloud-safe)
+
+\`\`\`js
+(() => {
+  const MODULE = "header"; // cambia por el nombre del módulo
+
+  const findRoot = () => {
+    const wrapped = document.querySelector(\`[data-mgpanel-module="\${MODULE}"]\`);
+    if (wrapped) return wrapped;
+    return document.querySelector(\`.mg-\${MODULE}\`);
+  };
+
+  const init = (rootOrEl) => {
+    if (!rootOrEl) return false;
+    const el = rootOrEl.classList?.contains(\`mg-\${MODULE}\`)
+      ? rootOrEl
+      : rootOrEl.querySelector?.(\`.mg-\${MODULE}\`);
+    if (!el) return false;
+
+    if (el.dataset.mgInit === "1") return true;
+    el.dataset.mgInit = "1";
+
+    // ... tu lógica aquí ...
+    return true;
+  };
+
+  const tryInit = () => init(findRoot());
+  if (tryInit()) return;
+
+  let tries = 0;
+  const t = window.setInterval(() => {
+    tries += 1;
+    if (tryInit() || tries > 200) window.clearInterval(t); // ~10s
+  }, 50);
+
+  const mo = new MutationObserver(() => {
+    if (tryInit()) mo.disconnect();
+  });
+  mo.observe(document.documentElement, { childList: true, subtree: true });
+
+  window.addEventListener("DOMContentLoaded", tryInit, { once: true });
+  window.addEventListener("load", tryInit, { once: true });
+})();
+\`\`\`
+
 ## Consejos para IDEs
 
 - Los archivos \`page.json\` definen la configuración de cada página
@@ -471,6 +609,17 @@ Este archivo contiene información detallada sobre:
 └── index.html          # Preview local
 \`\`\`
 
+## ✅ Nota importante (Local vs Nube)
+
+En local, \`dev/preview.js\` envuelve módulos en un contenedor \`data-mgpanel-module="..."\`, pero en MGPanel (nube) ese wrapper puede **no existir** y los módulos pueden inyectarse **después** de que el JS ya cargó.
+
+Por eso, al crear nuevos módulos con JavaScript:
+- No asumas que el HTML existe en el momento de ejecución.
+- Usa un patrón "cloud-safe" (retry + MutationObserver) y un selector con fallback (\`[data-mgpanel-module="x"]\` o \`.mg-x\`).
+- Usa rutas absolutas para assets (\`/assets/...\`) para evitar problemas de routing.
+
+Para más detalles, consulta la sección de compatibilidad en \`dev/config.md\`.
+
 ## 🔗 Más Información
 
 - **Documentación de desarrollo:** Ver \`dev/config.md\`
@@ -509,6 +658,7 @@ function cmdMakePage(pageName) {
         route: `/${pageName === "home" ? "" : pageName}`.replace(/\/$/, "/"),
         title: pageName.charAt(0).toUpperCase() + pageName.slice(1),
         description: `Descripción de la página ${pageName}.`,
+        directory: "",
         modules: []
       },
       null,
@@ -546,7 +696,7 @@ function cmdMakeModule(moduleName) {
   const jsPath = path.join(moduleDir, `${moduleName}.js`);
 
   const htmlContent = `<!-- Module: ${moduleName} -->
-<section class="${moduleName}">
+<section class="${moduleName} mg-${moduleName}">
   <h2>${moduleName}</h2>
   <p>Módulo creado con MGPanel ✅</p>
 </section>
@@ -559,7 +709,57 @@ function cmdMakeModule(moduleName) {
 `;
 
   const jsContent = `// Module: ${moduleName}
-console.log("[MGPanel] Module loaded:", "${moduleName}");
+// Patrón cloud-safe: funciona tanto en preview local como en MGPanel (nube)
+
+(() => {
+  const MODULE = "${moduleName}";
+
+  // Busca el root del módulo con fallback (local vs nube)
+  const findRoot = () => {
+    const wrapped = document.querySelector(\`[data-mgpanel-module="\${MODULE}"]\`);
+    if (wrapped) return wrapped;
+    return document.querySelector(\`.mg-\${MODULE}\`);
+  };
+
+  // Inicializa el módulo
+  const init = (rootOrEl) => {
+    if (!rootOrEl) return false;
+    const el = rootOrEl.classList?.contains(\`mg-\${MODULE}\`)
+      ? rootOrEl
+      : rootOrEl.querySelector?.(\`.mg-\${MODULE}\`);
+    if (!el) return false;
+
+    // Evitar doble inicialización
+    if (el.dataset.mgInit === "1") return true;
+    el.dataset.mgInit = "1";
+
+    // ... tu lógica aquí ...
+    console.log("[MGPanel] Module initialized:", MODULE);
+
+    return true;
+  };
+
+  // Intenta inicializar inmediatamente
+  const tryInit = () => init(findRoot());
+  if (tryInit()) return;
+
+  // Retry con intervalo (hasta ~10 segundos)
+  let tries = 0;
+  const intervalId = window.setInterval(() => {
+    tries += 1;
+    if (tryInit() || tries > 200) window.clearInterval(intervalId);
+  }, 50);
+
+  // Observar cambios en el DOM (para inyección tardía)
+  const mo = new MutationObserver(() => {
+    if (tryInit()) mo.disconnect();
+  });
+  mo.observe(document.documentElement, { childList: true, subtree: true });
+
+  // Escuchar eventos de carga
+  window.addEventListener("DOMContentLoaded", tryInit, { once: true });
+  window.addEventListener("load", tryInit, { once: true });
+})();
 `;
 
   const created = [];
@@ -574,6 +774,35 @@ console.log("[MGPanel] Module loaded:", "${moduleName}");
   if (skipped.length) console.log("↩️  Ya existían:", skipped.join(", "));
 }
 
+/**
+ * Verifica si un módulo existe en otras páginas (diferentes a la actual)
+ */
+function moduleExistsInOtherPages(moduleName, currentPageName) {
+  const pagesDir = path.join(process.cwd(), "pages");
+  if (!fs.existsSync(pagesDir)) return false;
+  
+  const pageDirs = fs.readdirSync(pagesDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory() && dirent.name !== currentPageName)
+    .map(dirent => dirent.name);
+  
+  for (const pageName of pageDirs) {
+    const pageJsonPath = path.join(pagesDir, pageName, "page.json");
+    if (fs.existsSync(pageJsonPath)) {
+      try {
+        const page = readJSON(pageJsonPath);
+        if (Array.isArray(page.modules)) {
+          const exists = page.modules.some(m => m && m.name === moduleName);
+          if (exists) return true;
+        }
+      } catch (e) {
+        // Si hay error leyendo el archivo, continuar con la siguiente página
+        continue;
+      }
+    }
+  }
+  return false;
+}
+
 /**
  * mgpanel add module <moduleName> --to <pageName>
  */
@@ -607,10 +836,402 @@ function cmdAddModule(moduleName, pageName) {
     return;
   }
 
-  page.modules.push({ name: moduleName });
+  // Determinar si el módulo es importado (existe en otras páginas)
+  const isImported = moduleExistsInOtherPages(moduleName, pageName);
+  page.modules.push({ 
+    name: moduleName, 
+    import: isImported 
+  });
   writeJSON(pageJsonPath, page);
 
-  console.log(`✅ Módulo "${moduleName}" agregado a pages/${pageName}/page.json`);
+  const importStatus = isImported ? "importado" : "propio";
+  console.log(`✅ Módulo "${moduleName}" agregado a pages/${pageName}/page.json (${importStatus})`);
+}
+
+/**
+ * mgpanel publish --account <cuenta> [--token <token>] [--api-url <url>]
+ */
+async function cmdPublish(args) {
+  // Parsear argumentos
+  let account = null;
+  let token = null;
+  let apiUrl = "https://dev.mgpanel.co"; // default
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--account" && args[i + 1]) {
+      account = args[i + 1];
+      i++;
+    } else if (args[i] === "--token" && args[i + 1]) {
+      token = args[i + 1];
+      i++;
+    } else if (args[i] === "--api-url" && args[i + 1]) {
+      apiUrl = args[i + 1];
+      i++;
+    }
+  }
+
+  // Cargar variables de entorno desde .env si existe
+  const envPath = path.join(process.cwd(), ".env");
+  if (fs.existsSync(envPath)) {
+    const envContent = fs.readFileSync(envPath, "utf8");
+    const envLines = envContent.split("\n");
+    for (const line of envLines) {
+      const trimmed = line.trim();
+      // Ignorar comentarios y líneas vacías
+      if (trimmed && !trimmed.startsWith("#")) {
+        const match = trimmed.match(/^([^=]+)=(.*)$/);
+        if (match) {
+          const key = match[1].trim();
+          const value = match[2].trim().replace(/^["']|["']$/g, ""); // Remover comillas
+          if (key === "MGPANEL_TOKEN") {
+            process.env.MGPANEL_TOKEN = value;
+          } else if (key === "MGPANEL_API_URL") {
+            process.env.MGPANEL_API_URL = value;
+          }
+        }
+      }
+    }
+  }
+
+  // Token puede venir de variable de entorno
+  if (!token) {
+    token = process.env.MGPANEL_TOKEN;
+  }
+
+  // API URL puede venir de variable de entorno (tiene prioridad sobre default)
+  if (process.env.MGPANEL_API_URL) {
+    apiUrl = process.env.MGPANEL_API_URL;
+  }
+
+  // Validaciones
+  if (!account) {
+    console.log("❌ Falta el parámetro --account");
+    console.log("👉 Usa: mgpanel publish --account <nombre-cuenta> [--token <token>] [--api-url <url>]");
+    process.exit(1);
+  }
+
+  if (!token) {
+    console.log("❌ Falta el token de autenticación");
+    console.log("👉 Usa: mgpanel publish --account <cuenta> --token <token>");
+    console.log("   O configura la variable de entorno: MGPANEL_TOKEN");
+    console.log("   O agrega MGPANEL_TOKEN=tu-token en el archivo .env");
+    process.exit(1);
+  }
+
+  // Mostrar información del token (solo primeros y últimos caracteres por seguridad)
+  const tokenPreview = token.length > 10 
+    ? `${token.substring(0, 6)}...${token.substring(token.length - 4)}`
+    : "***";
+  console.log(`🔑 Token: ${tokenPreview}`);
+
+  const projectRoot = process.cwd();
+  const pagesDir = path.join(projectRoot, "pages");
+  const modulesDir = path.join(projectRoot, "modules");
+  const assetsDir = path.join(projectRoot, "assets");
+
+  // Validar que estamos en un proyecto MGPanel
+  if (!fs.existsSync(pagesDir) || !fs.existsSync(modulesDir)) {
+    console.log("❌ No se encontró un proyecto MGPanel válido");
+    console.log("👉 Asegúrate de estar en un directorio con carpetas 'pages' y 'modules'");
+    console.log("   O ejecuta: mgpanel init <nombre-proyecto>");
+    process.exit(1);
+  }
+
+  console.log("📦 Leyendo estructura del proyecto...");
+
+  try {
+    // Leer assets globales
+    const globalCSS = fs.existsSync(path.join(assetsDir, "css", "style.css"))
+      ? fs.readFileSync(path.join(assetsDir, "css", "style.css"), "utf8")
+      : "";
+    const globalJS = fs.existsSync(path.join(assetsDir, "js", "app.js"))
+      ? fs.readFileSync(path.join(assetsDir, "js", "app.js"), "utf8")
+      : "";
+
+    // Leer todas las páginas
+    const pages = [];
+    const pageDirs = fs.readdirSync(pagesDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+
+    console.log(`📂 Páginas encontradas en directorio: ${pageDirs.length} (${pageDirs.join(", ")})`);
+
+    for (const pageName of pageDirs) {
+      console.log(`📄 Procesando página: ${pageName}`);
+      // Compatibilidad: algunas personas lo renombraron a "pago.json" por error.
+      // Preferimos "page.json", pero aceptamos "pago.json" como fallback.
+      const pageJsonPath = path.join(pagesDir, pageName, "page.json");
+      const pagoJsonPath = path.join(pagesDir, pageName, "pago.json");
+      let pageConfigPath = null;
+
+      if (fs.existsSync(pageJsonPath)) {
+        pageConfigPath = pageJsonPath;
+      } else if (fs.existsSync(pagoJsonPath)) {
+        pageConfigPath = pagoJsonPath;
+        console.log(`⚠️  Aviso: usando "${pageName}/pago.json". Recomendado: renómbralo a "page.json".`);
+      } else {
+        console.log(`⚠️  Saltando página "${pageName}": no se encontró page.json (ni pago.json)`);
+        continue;
+      }
+
+      let pageConfig;
+      try {
+        pageConfig = readJSON(pageConfigPath);
+      } catch (error) {
+        console.log(`❌ Error al leer ${pageConfigPath}: ${error.message}`);
+        console.log(`⚠️  Saltando página "${pageName}"`);
+        continue;
+      }
+
+      const sections = [];
+
+      // Procesar módulos de la página
+      if (Array.isArray(pageConfig.modules)) {
+        for (let i = 0; i < pageConfig.modules.length; i++) {
+          const moduleName = pageConfig.modules[i].name;
+          if (!moduleName) continue;
+
+          const moduleDir = path.join(modulesDir, moduleName);
+          if (!fs.existsSync(moduleDir)) {
+            console.log(`⚠️  Módulo "${moduleName}" no encontrado, saltando...`);
+            continue;
+          }
+
+          const moduleHTML = fs.existsSync(path.join(moduleDir, `${moduleName}.html`))
+            ? fs.readFileSync(path.join(moduleDir, `${moduleName}.html`), "utf8")
+            : "";
+          const moduleCSS = fs.existsSync(path.join(moduleDir, `${moduleName}.css`))
+            ? fs.readFileSync(path.join(moduleDir, `${moduleName}.css`), "utf8")
+            : "";
+          const moduleJS = fs.existsSync(path.join(moduleDir, `${moduleName}.js`))
+            ? fs.readFileSync(path.join(moduleDir, `${moduleName}.js`), "utf8")
+            : "";
+
+          // Leer el campo import del page.json (por defecto false si no existe)
+          const moduleConfig = pageConfig.modules[i];
+          const isImported = moduleConfig.import === true || moduleConfig.import === "true";
+
+          sections.push({
+            code: moduleName,
+            name: moduleName,
+            html: {
+              type: "text/html",
+              code: moduleHTML
+            },
+            css: {
+              type: "text/css",
+              code: moduleCSS
+            },
+            javascript: {
+              type: "application/javascript",
+              code: moduleJS
+            },
+            module: [], // Array de referencias a módulos (el backend lo manejará)
+            order: i + 1,
+            status: 1,
+            import: isImported
+          });
+        }
+      }
+
+      // Validar que la página tenga al menos un campo requerido
+      if (!pageConfig.title && !pageName) {
+        console.log(`⚠️  Saltando página "${pageName}": falta información básica`);
+        continue;
+      }
+
+      pages.push({
+        // page: ObjectId - El backend debe generar o usar el existente
+        name: pageName,
+        title: pageConfig.title || pageName,
+        description: pageConfig.description || "",
+        // IMPORTANTE: en MGPanel el `directory` por defecto debe ser "".
+        // No usar `|| pageName` porque "" es válido y si cae al fallback rompe el render (termina guardando "home", "about", etc.).
+        directory: (typeof pageConfig.directory === "string") ? pageConfig.directory : "",
+        url: pageConfig.route || `/${pageName === "home" ? "" : pageName}`,
+        sections: sections,
+        status: 1,
+        soon: false,
+        index: pageName === "home"
+      });
+      
+      console.log(`✅ Página "${pageName}" procesada (${sections.length} secciones)`);
+    }
+
+    console.log(`📊 Total de páginas procesadas: ${pages.length}`);
+
+    // Seguridad: nunca publicar si no se encontró ninguna página.
+    if (pages.length === 0) {
+      console.log("❌ No se encontró ninguna página para publicar.");
+      console.log("👉 Verifica que existan carpetas en ./pages/<pagina>/ y que el archivo sea page.json (o pago.json).");
+      console.log(`💡 Directorios encontrados: ${pageDirs.length > 0 ? pageDirs.join(", ") : "ninguno"}`);
+      process.exit(1);
+    }
+
+    // Construir payload según modelo MongoDB
+    const payload = {
+      type: "published",
+      css: {
+        type: "text/css",
+        code: globalCSS
+      },
+      javascript: {
+        type: "application/javascript",
+        code: globalJS
+      },
+      pages: pages,
+      modified_date: new Date(),
+      has_changes: true,
+      version_number: 1
+    };
+
+    console.log(`📤 Publicando a cuenta: ${account}`);
+    console.log(`📄 Páginas encontradas: ${pages.length}`);
+    console.log(`🧩 Módulos totales: ${pages.reduce((sum, p) => sum + p.sections.length, 0)}`);
+    console.log(`🌐 URL de la API: ${apiUrl}`);
+
+    // Enviar POST request
+    const url = new URL(`${apiUrl}/api/cli/publish`);
+    const postData = JSON.stringify(payload);
+    const urlOptions = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname + url.search,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(postData),
+        "Authorization": `Bearer ${token}`,
+        "X-Account-Nick": account
+      },
+      timeout: 60000, // 60 segundos de timeout
+      rejectUnauthorized: true, // Aceptar certificados SSL válidos
+      agent: false // No usar agent pool, crear nueva conexión
+    };
+
+    const client = url.protocol === "https:" ? https : http;
+
+    console.log(`🔄 Enviando petición a ${url.hostname}${url.pathname}...`);
+    console.log(`📤 Tamaño del payload: ${Buffer.byteLength(postData)} bytes`);
+
+    // Usar promesa para asegurar que esperamos la respuesta
+    await new Promise((resolve, reject) => {
+      console.log(`🔧 Creando request HTTP...`);
+      const req = client.request(urlOptions, (res) => {
+        console.log(`✅ Callback del request ejecutado`);
+        let responseData = "";
+
+        console.log(`📡 Respuesta recibida: ${res.statusCode} ${res.statusMessage || ""}`);
+
+        // Manejar errores de respuesta
+        res.on("error", (err) => {
+          console.log(`❌ Error al leer la respuesta: ${err.message}`);
+          reject(err);
+        });
+
+        res.on("data", (chunk) => {
+          responseData += chunk;
+          console.log(`📥 Recibiendo datos... (${responseData.length} bytes acumulados)`);
+        });
+
+        res.on("end", () => {
+          console.log(`✅ Evento 'end' disparado`);
+          console.log(`📦 Tamaño de respuesta: ${responseData.length} bytes`);
+          
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            console.log("✅ Publicación exitosa!");
+            try {
+              const response = JSON.parse(responseData);
+              if (response.message) {
+                console.log(`📝 ${response.message}`);
+              }
+              if (response.data) {
+                console.log(`📊 Versión: ${response.data.version_number || "N/A"}`);
+              }
+              if (response.success === false) {
+                console.log(`⚠️  El servidor reportó: success=false`);
+                console.log(`💬 ${JSON.stringify(response, null, 2)}`);
+              }
+            } catch (e) {
+              // No es JSON, mostrar respuesta tal cual
+              if (responseData) {
+                console.log(`📝 Respuesta (texto): ${responseData.substring(0, 500)}`);
+              } else {
+                console.log(`📝 Respuesta vacía`);
+              }
+            }
+            resolve();
+          } else {
+            console.log(`❌ Error en la publicación (${res.statusCode})`);
+            try {
+              const error = JSON.parse(responseData);
+              console.log(`💬 ${error.message || error.error || "Error desconocido"}`);
+              if (error.details) {
+                console.log(`🔍 Detalles:`, JSON.stringify(error.details, null, 2));
+              }
+            } catch (e) {
+              if (responseData) {
+                console.log(`💬 Respuesta del servidor: ${responseData.substring(0, 500)}`);
+              } else {
+                console.log(`💬 Sin respuesta del servidor`);
+              }
+            }
+            reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
+          }
+        });
+      });
+
+      req.on("error", (error) => {
+        console.log(`❌ Error de conexión: ${error.message}`);
+        console.log(`💡 Código de error: ${error.code || "N/A"}`);
+        console.log(`💡 Stack: ${error.stack || "N/A"}`);
+        console.log(`💡 Verifica que la URL de la API sea correcta: ${apiUrl}`);
+        if (error.code === "ENOTFOUND") {
+          console.log(`💡 No se pudo resolver el hostname: ${url.hostname}`);
+        } else if (error.code === "ECONNREFUSED") {
+          console.log(`💡 Conexión rechazada. ¿El servidor está corriendo?`);
+        } else if (error.code === "ETIMEDOUT") {
+          console.log(`💡 Timeout de conexión. El servidor no respondió a tiempo.`);
+        } else if (error.code === "CERT_HAS_EXPIRED" || error.code === "UNABLE_TO_VERIFY_LEAF_SIGNATURE") {
+          console.log(`💡 Problema con el certificado SSL. Intenta con rejectUnauthorized: false (solo para desarrollo)`);
+        }
+        reject(error);
+      });
+
+      req.setTimeout(60000, () => {
+        console.log(`❌ Timeout: La petición tardó más de 60 segundos sin respuesta`);
+        console.log(`💡 El servidor puede estar sobrecargado o hay un problema de red`);
+        req.destroy();
+        reject(new Error("Timeout"));
+      });
+
+      console.log(`📤 Escribiendo datos en el request...`);
+      req.write(postData);
+      console.log(`✅ Datos escritos, cerrando request...`);
+      req.end();
+      
+      console.log(`📨 Petición enviada, esperando respuesta...`);
+      
+      // Agregar listener para verificar si el request se está enviando
+      req.on("finish", () => {
+        console.log(`✅ Request finalizado (datos enviados)`);
+      });
+      
+      req.on("close", () => {
+        console.log(`🔒 Conexión cerrada`);
+      });
+    }).catch((error) => {
+      console.log(`❌ Error en la promesa: ${error.message}`);
+      throw error;
+    });
+
+  } catch (error) {
+    console.log(`❌ Error al procesar el proyecto: ${error.message}`);
+    if (error.stack) {
+      console.log(error.stack);
+    }
+    process.exit(1);
+  }
 }
 
 function cmdDev(port = 3000) {
@@ -720,6 +1341,23 @@ if (cmd1 === "dev") {
   return;
 }
 
+if (cmd1 === "publish") {
+  (async () => {
+    try {
+      await cmdPublish(args);
+      process.exit(0);
+    } catch (error) {
+      console.log(`❌ Error: ${error.message}`);
+      if (error.stack) {
+        console.log(error.stack);
+      }
+      process.exit(1);
+    }
+  })();
+  // NO hacer process.exit aquí, dejar que la función async maneje la salida
+  return; // Evitar que el código continúe
+}
+
 console.log("❌ Comando no reconocido.");
 printHelp();
 process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mgpanel-cli",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "MGPanel CLI",
   "bin": {
     "mgpanel": "./bin/mgpanel.js"