gesicomm-mcp 0.0.0-stage → 1.0.0

package/bin/cli.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createGesicommServer } from '../src/server.js';
+
+async function main() {
+  const server = createGesicommServer();
+  const transport = new StdioServerTransport();
+
+  // IMPORTANTE en MCP: Todo logging o debug DEBE salir por stderr.
+  // stdout es reservado exclusivamente para el protocolo JSON-RPC de MCP.
+  console.error('[gesicomm-mcp] Iniciando servidor MCP de Gesicomm...');
+  console.error(`[gesicomm-mcp] API URL: ${process.env.GESICOMM_API_URL || 'http://localhost:5000/api'}`);
+  if (process.env.GESICOMM_LANDING_ID) {
+    console.error(`[gesicomm-mcp] Landing ID por defecto: ${process.env.GESICOMM_LANDING_ID}`);
+  }
+
+  await server.connect(transport);
+  console.error('[gesicomm-mcp] Conectado exitosamente via stdio.');
+}
+
+main().catch((err) => {
+  console.error('[gesicomm-mcp] Error fatal:', err);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "gesicomm-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Servidor MCP oficial de Gesicomm para Claude y Codex",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "gesicomm-mcp": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "gesicomm",
+    "ecommerce",
+    "claude",
+    "codex"
+  ],
+  "scripts": {
+    "start": "node bin/cli.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "dotenv": "^16.4.5",
+    "zod": "^3.25.76"
+  }
+}

package/src/apiClient.js

@@ -0,0 +1,95 @@
+/**
+ * Cliente HTTP para comunicarse con la API de Gesicomm.
+ */
+
+export class GesicommApiClient {
+  constructor({ apiUrl, token, tiendaId }) {
+    let url = (apiUrl || process.env.GESICOMM_API_URL || 'https://api.gesicomm.com/api').trim().replace(/\/+$/, '');
+    
+    // Si el usuario configuró el dominio del frontend (gesicomm.com), redirigir automáticamente a api.gesicomm.com/api
+    if (url === 'https://gesicomm.com' || url === 'http://gesicomm.com' || url === 'https://gesicomm.com/api' || url === 'http://gesicomm.com/api') {
+      url = 'https://api.gesicomm.com/api';
+    } else if (url === 'https://www.gesicomm.com' || url === 'http://www.gesicomm.com' || url === 'https://www.gesicomm.com/api' || url === 'http://www.gesicomm.com/api') {
+      url = 'https://api.gesicomm.com/api';
+    } else if (!url.endsWith('/api') && !url.includes('localhost') && !url.includes('127.0.0.1')) {
+      url = `${url}/api`;
+    }
+
+    this.apiUrl = url;
+    this.token = token || process.env.GESICOMM_TOKEN || '';
+    this.tiendaId = tiendaId || process.env.GESICOMM_TIENDA_ID || null;
+  }
+
+  async _request(path, options = {}) {
+    if (!this.token) {
+      throw new Error('Falta el token de autenticación de Gesicomm (GESICOMM_TOKEN). Generalo desde Gesicomm > Lienzo en blanco.');
+    }
+
+    const url = new URL(`${this.apiUrl}${path}`);
+    if (this.tiendaId && !url.searchParams.has('tienda_id')) {
+      url.searchParams.set('tienda_id', this.tiendaId);
+    }
+
+    const headers = {
+      'Authorization': `Bearer ${this.token}`,
+      'Content-Type': 'application/json',
+      ...(options.headers || {}),
+    };
+
+    const res = await fetch(url.toString(), {
+      ...options,
+      headers,
+    });
+
+    const rawText = await res.text();
+    let data;
+    try {
+      data = JSON.parse(rawText);
+    } catch {
+      if (rawText.includes('<!DOCTYPE') || rawText.includes('<html')) {
+        throw new Error(`El servidor en ${this.apiUrl} respondió con una página HTML en lugar de JSON. Si estás probando en desarrollo local, usá http://localhost:5000/api o asegurate de que el backend en producción tenga desplegados los endpoints /api/mcp.`);
+      }
+      throw new Error(`Respuesta inválida del servidor (código ${res.status}): ${rawText.substring(0, 150)}`);
+    }
+
+    if (!res.ok) {
+      const msg = data.error || data.message || `Error en la solicitud a Gesicomm (${res.status})`;
+      const err = new Error(msg);
+      err.status = res.status;
+      err.detalles = data;
+      throw err;
+    }
+
+    return data;
+  }
+
+  async listarLandings() {
+    const data = await this._request('/mcp/landings');
+    return data.landings || [];
+  }
+
+  async obtenerContexto(landingId) {
+    const data = await this._request(`/mcp/landings/${landingId}/contexto`);
+    return data.contexto;
+  }
+
+  async obtenerCodigo(landingId, vista = 'inicio', contentId = null) {
+    const query = new URLSearchParams({ vista });
+    if (contentId) query.set('content_id', contentId);
+    return this._request(`/mcp/landings/${landingId}/codigo?${query.toString()}`);
+  }
+
+  async validarCodigo(landingId, html, vista = 'inicio') {
+    return this._request(`/mcp/landings/${landingId}/validar`, {
+      method: 'POST',
+      body: JSON.stringify({ html, vista }),
+    });
+  }
+
+  async guardarCodigo(landingId, { vista = 'inicio', html, css = '', js = '', contentId = null }) {
+    return this._request(`/mcp/landings/${landingId}/codigo`, {
+      method: 'POST',
+      body: JSON.stringify({ vista, html, css, js, contentId }),
+    });
+  }
+}

package/src/index.js

@@ -0,0 +1,2 @@
+export { createGesicommServer } from './server.js';
+export { GesicommApiClient } from './apiClient.js';

package/src/server.js

@@ -0,0 +1,191 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { GesicommApiClient } from './apiClient.js';
+
+export function createGesicommServer(config = {}) {
+  const client = new GesicommApiClient(config);
+  const defaultLandingId = process.env.GESICOMM_LANDING_ID ? Number(process.env.GESICOMM_LANDING_ID) : null;
+
+  const server = new McpServer({
+    name: 'gesicomm-mcp',
+    version: '1.0.0',
+  });
+
+  // Tool 1: Listar Landings
+  server.tool(
+    'gesicomm_listar_landings',
+    'Lista las landings activas y en borrador de la tienda en Gesicomm para conocer sus IDs y títulos.',
+    {},
+    async () => {
+      try {
+        const landings = await client.listarLandings();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(landings, null, 2),
+          }],
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: `Error al listar landings: ${err.message}` }],
+        };
+      }
+    }
+  );
+
+  // Tool 2: Obtener Contexto Comercial Completo
+  server.tool(
+    'gesicomm_obtener_contexto_landing',
+    'Obtiene el contexto comercial completo de la landing: catálogo de productos con precios en Guaraníes (PYG), imágenes, variantes, ofertas (order bumps, packs), branding de la tienda y el contrato técnico de directivas obligatorias para que el carrito, los pedidos y el Píxel funcionen.',
+    {
+      landing_id: z.number().int().positive().optional().describe('ID numérico de la landing en Gesicomm (si se omite, usa GESICOMM_LANDING_ID)'),
+    },
+    async ({ landing_id }) => {
+      const id = landing_id || defaultLandingId;
+      if (!id) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: 'Debes proporcionar landing_id o configurar GESICOMM_LANDING_ID.' }],
+        };
+      }
+      try {
+        const contexto = await client.obtenerContexto(id);
+        if (!contexto) {
+          throw new Error(`No se pudo obtener el contexto de la landing #${id}. Verificá que la landing exista y pertenezca a tu tienda.`);
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(contexto, null, 2),
+          }],
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: `Error al obtener contexto comercial de la landing #${id}: ${err.message}` }],
+        };
+      }
+    }
+  );
+
+  // Tool 3: Leer Código de la Landing
+  server.tool(
+    'gesicomm_leer_codigo_landing',
+    'Lee el código actual (HTML, CSS, JS) de una vista específica de la landing (inicio, producto, catalogo, checkout, legal) para poder inspeccionarlo, mejorarlo o modificarlo.',
+    {
+      landing_id: z.number().int().positive().optional().describe('ID numérico de la landing'),
+      vista: z.enum(['inicio', 'producto', 'catalogo', 'checkout', 'legal']).default('inicio').describe('Vista a consultar'),
+      content_id: z.string().optional().describe('Para fichas propias de un producto específico, el content_id (ej: "producto-15")'),
+    },
+    async ({ landing_id, vista, content_id }) => {
+      const id = landing_id || defaultLandingId;
+      if (!id) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: 'Debes proporcionar landing_id o configurar GESICOMM_LANDING_ID.' }],
+        };
+      }
+      try {
+        const data = await client.obtenerCodigo(id, vista, content_id);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(data, null, 2),
+          }],
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: `Error al leer código de la landing #${id}: ${err.message}` }],
+        };
+      }
+    }
+  );
+
+  // Tool 4: Validar Motor Comercial
+  server.tool(
+    'gesicomm_validar_motor_comercial',
+    'Audita un fragmento o documento HTML antes de guardarlo, verificando que tenga los botones de compra (data-gesicomm-comprar/agregar), casillas de order bump, selector de variantes y binds de precios necesarios para procesar pedidos y activar el Píxel de Meta.',
+    {
+      html: z.string().describe('Código HTML a validar'),
+      vista: z.enum(['inicio', 'producto', 'catalogo', 'checkout', 'legal']).default('inicio').describe('Vista a validar'),
+      landing_id: z.number().int().positive().optional().describe('ID de la landing (opcional)'),
+    },
+    async ({ html, vista, landing_id }) => {
+      const id = landing_id || defaultLandingId;
+      try {
+        let res;
+        if (id) {
+          res = await client.validarCodigo(id, html, vista);
+        } else {
+          // Validación local básica si no hay id
+          const tieneComprar = /data-gesicomm-comprar/.test(html) || /data-gesicomm-agregar/.test(html);
+          res = {
+            valido: tieneComprar,
+            errores: tieneComprar ? [] : ['Falta botón de compra: El HTML debe contener data-gesicomm-comprar o data-gesicomm-agregar.'],
+            advertencias: [],
+            sugerencias: [],
+          };
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(res, null, 2),
+          }],
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: `Error en validación: ${err.message}` }],
+        };
+      }
+    }
+  );
+
+  // Tool 5: Guardar Código en Gesicomm
+  server.tool(
+    'gesicomm_guardar_codigo_landing',
+    'Guarda el código HTML/CSS/JS generado o modificado en la base de datos de Gesicomm. Valida automáticamente las directivas comerciales y sanitiza el código antes de persistirlo. La vista previa en Gesicomm se actualizará al instante.',
+    {
+      landing_id: z.number().int().positive().optional().describe('ID numérico de la landing'),
+      vista: z.enum(['inicio', 'producto', 'catalogo', 'checkout', 'legal']).default('inicio').describe('Vista a actualizar'),
+      html: z.string().describe('Código HTML de la vista'),
+      css: z.string().optional().default('').describe('Estilos CSS de la vista'),
+      js: z.string().optional().default('').describe('JavaScript de la vista (opcional)'),
+      content_id: z.string().optional().describe('Content ID si es la ficha propia de un producto específico'),
+    },
+    async ({ landing_id, vista, html, css, js, content_id }) => {
+      const id = landing_id || defaultLandingId;
+      if (!id) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: 'Debes proporcionar landing_id o configurar GESICOMM_LANDING_ID.' }],
+        };
+      }
+      try {
+        const resultado = await client.guardarCodigo(id, {
+          vista,
+          html,
+          css,
+          js,
+          contentId: content_id,
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(resultado, null, 2),
+          }],
+        };
+      } catch (err) {
+        const detalles = err.detalles?.errores ? `\nErrores encontrados:\n- ${err.detalles.errores.join('\n- ')}` : '';
+        return {
+          isError: true,
+          content: [{ type: 'text', text: `Error al guardar en Gesicomm: ${err.message}${detalles}` }],
+        };
+      }
+    }
+  );
+
+  return server;
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.