Encrypted SQLite MCP Server

Servidor MCP para bases de datos SQLite cifradas

Un servidor de Model Context Protocol (MCP) para trabajar con bases de datos SQLite cifradas mediante SQLCipher. Este servidor proporciona herramientas para leer estructuras de bases de datos, consultar tablas y realizar operaciones CRUD sobre bases de datos SQLite cifradas.

Compatible con todos los clientes MCP (Cursor, Claude Desktop y otros).

Funciona con bases de datos cifradas de: MoneyMoney, 1Password, Signal, WhatsApp, Firefox, Telegram, KeePass y otras aplicaciones que utilizan cifrado SQLCipher.

Características

• Compatibilidad con SQLite cifrado: Funciona con bases de datos cifradas con SQLCipher 4: el diferenciador clave de este servidor MCP

• Frases de contraseña cifradas: Compatibilidad con frases de contraseña cifradas con AES-256-GCM e integración con macOS Keychain

• Exploración de bases de datos: Enumera tablas, columnas, índices y metadatos de esquema

• Compatibilidad con consultas: Ejecuta consultas SQL arbitrarias (SELECT, INSERT, UPDATE, DELETE, DDL)

• Operaciones CRUD: Inserta, actualiza y elimina filas con filtrado

• Perfiles de cifrado configurables: Compatibilidad con diferentes configuraciones de SQLCipher

• Protocolo MCP: Implementación completa del Model Context Protocol a través de STDIO

• Seguridad: Validación de identificadores SQL para prevenir la inyección de SQL

• Modo de depuración: Salida de depuración opcional mediante la variable de entorno MCP_DEBUG

• Validación de entradas: Validación exhaustiva de límites, desplazamientos e identificadores

Related MCP server: mcp-sqlite

¿Por qué SQLite cifrado?

Muchas aplicaciones populares utilizan bases de datos SQLite cifradas (SQLCipher) para proteger datos sensibles. Este servidor MCP está diseñado específicamente para trabajar con estas bases de datos cifradas.

Aplicaciones que utilizan bases de datos SQLite cifradas

• MoneyMoney (macOS): Aplicación de gestión financiera con bases de datos locales cifradas

• 1Password: Gestor de contraseñas que utiliza SQLCipher para el almacenamiento local de bóvedas

• Signal: Aplicación de mensajería cifrada con bases de datos de mensajes protegidas por SQLCipher

• WhatsApp: Aplicación de mensajería que utiliza SQLite cifrado para el almacenamiento local de mensajes

• Firefox: Navegador que utiliza SQLCipher para las bases de datos de credenciales cifradas

• Telegram: Aplicación de mensajería con almacenamiento local de base de datos cifrada

• KeePass: Gestor de contraseñas compatible con archivos de bases de datos SQLite cifradas

Si necesitas acceder a los datos de cualquiera de estas aplicaciones o de otras bases de datos cifradas con SQLCipher, este servidor MCP te proporciona las herramientas necesarias. Ten en cuenta que necesitas la frase de contraseña de la base de datos cifrada.

Requisitos

• Java 21 o superior (JDK)

• Gradle (wrapper incluido)

• Controlador JDBC de SQLite con soporte de cifrado (sqlite-jdbc-3.50.1.0.jar de lanzamientos de sqlite-jdbc-crypt)

Inicio rápido

Cursor (instalación en un clic)

La forma más sencilla de instalar este servidor MCP en Cursor es a través de Cursor MCP Store:

1. Visita cursor.store/mcp/rosch100/mcp-encrypted-sqlite

2. Haz clic en "Añadir a Cursor"

3. Sigue las indicaciones para configurar la ruta de tu base de datos y tu frase de contraseña

Otros clientes MCP

Este servidor funciona con cualquier cliente compatible con MCP. Consulta la sección Configuración a continuación para obtener instrucciones de configuración.

Instalación

Docker (recomendado)

Usa la imagen Docker predefinida de GitHub Container Registry:

docker pull ghcr.io/rosch100/mcp-encrypted-sqlite:latest

Inicio rápido: Consulta DOCKER_QUICKSTART.md para la configuración de Docker Desktop.

Configuración detallada: Consulta DOCKER_CONFIGURATION.md para opciones avanzadas.

Desde el código fuente

1. Clona el repositorio:

   git clone https://github.com/rosch100/mcp-encrypted-sqlite.git

   cd mcp-encrypted-sqlite

2. Compila el proyecto:

   ./gradlew build installDist

El proceso de compilación descargará automáticamente sqlite-jdbc-3.50.1.0.jar desde lanzamientos de sqlite-jdbc-crypt y lo colocará en el directorio libs/.

El ejecutable estará disponible en build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite.

Configuración

Este servidor MCP funciona con cualquier cliente compatible con MCP (Cursor, Claude Desktop, etc.). El formato de configuración sigue la especificación del Model Context Protocol.

El servidor se comunica a través de STDIO (entrada/salida estándar). Añade la siguiente configuración al archivo de configuración de tu cliente MCP:

Ubicaciones de los archivos de configuración:

• Cursor: ~/.cursor/mcp.json

• Claude Desktop (macOS): ~/Library/Application Support/Claude/claude_desktop_config.json

• Claude Desktop (Windows): %APPDATA%\Claude\claude_desktop_config.json

• Otros clientes: consulta la documentación de tu cliente

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
      ]
    }
  }
}

Parámetros opcionales:

• transport: el valor predeterminado es "stdio" (se puede omitir)

• cwd: no es necesario cuando se usan rutas absolutas (se puede omitir)

• immutable: booleano opcional en el JSON de --args. Cuando es true, abre la base de datos con la URI SQLite file:…?immutable=1 (sin bloqueos de archivo). Úsalo para inspeccionar bases de datos bloqueadas en exclusiva por otra aplicación (p. ej., MoneyMoney). Todas las herramientas/SQL de escritura están deshabilitadas en este modo (insert_or_update / delete_rows se omiten; execute_sql solo acepta sentencias de solo lectura).

• env: solo es necesario si Java no está en tu PATH del sistema o para una instalación personalizada de Java:

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
      ],
      "env": {
        "JAVA_HOME": "/path/to/java/home"
      }
    }
  }
}

Configuración de Docker

Frase de contraseña sin cifrar

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-v", "/path/to/your/database.sqlite:/data/database.sqlite:ro",
        "ghcr.io/rosch100/mcp-encrypted-sqlite:latest",
        "--args",
        "{\"db_path\":\"/data/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
      ]
    }
  }
}

Frase de contraseña cifrada (recomendado)

Cuando utilices frases de contraseña cifradas, debes pasar la clave de cifrado como variable de entorno:

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "MCP_SQLITE_ENCRYPTION_KEY=your-encryption-key",
        "-v", "/path/to/your/database.sqlite:/data/database.sqlite:ro",
        "ghcr.io/rosch100/mcp-encrypted-sqlite:latest",
        "--args",
        "{\"db_path\":\"/data/database.sqlite\",\"passphrase\":\"encrypted:your-encrypted-passphrase\"}"
      ]
    }
  }
}

Notas importantes:

• La opción -e debe ir antes de la opción -v

• macOS Keychain NO es accesible desde contenedores Docker: pasa la clave de cifrado explícitamente

• Obtén tu clave de cifrado: security find-generic-password -s "mcp-encrypted-sqlite" -a "encryption-key" -w

• El archivo de base de datos se monta como de solo lectura (:ro) de forma predeterminada. Elimina :ro si necesitas acceso de escritura

Advertencia de seguridad: almacenar tanto la clave de cifrado como la frase de contraseña cifrada como texto plano en tu archivo de configuración es un riesgo de seguridad. Consulta DOCKER_CONFIGURATION.md para alternativas seguras.

Perfil de cifrado personalizado

Anula la configuración predeterminada de SQLCipher 4 incluyendo un cipherProfile en el JSON de configuración:

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\",\"cipherProfile\":{\"name\":\"SQLCipher 4 defaults\",\"pageSize\":4096,\"kdfIterations\":256000,\"hmacAlgorithm\":\"HMAC_SHA512\",\"kdfAlgorithm\":\"PBKDF2_HMAC_SHA512\"}}"
      ]
    }
  }
}

Nota: todos los campos de cipherProfile son opcionales: especifica solo los que quieras anular de los valores predeterminados. También puedes especificar cipherProfile en llamadas individuales a herramientas, pero se recomienda configurarlo una vez en la configuración del servidor MCP para mantener la coherencia.

Frases de contraseña cifradas

Para mayor seguridad, puedes almacenar las frases de contraseña en forma cifrada. El servidor utiliza cifrado AES-256-GCM, que proporciona cifrado autenticado y es a la vez seguro y rápido.

macOS Keychain (recomendado para macOS)

1. Genera y almacena la clave en Keychain: Ejecuta: ./store-key-in-keychain.sh --generate

2. Cifra tu frase de contraseña: Ejecuta: ./encrypt-passphrase.sh "your-plain-passphrase"

La clave se carga automáticamente desde Keychain cuando no se ha establecido ninguna variable de entorno.

Ventajas:

• La clave se cifra y almacena de forma segura con macOS

• No se necesitan variables de entorno

• Desbloqueo automático con la contraseña de usuario de macOS

• Funciona en todo el sistema para todas las aplicaciones

Variable de entorno (multiplataforma)

1. Genera una clave de cifrado: Ejecuta: java -cp build/libs/mcp-encrypted-sqlite-VERSION.jar com.example.mcp.sqlite.config.PassphraseEncryption

2. Establece la clave de cifrado: Ejecuta: export MCP_SQLITE_ENCRYPTION_KEY="<your-generated-key>"

3. Cifra tu frase de contraseña: Ejecuta: java -cp build/libs/mcp-encrypted-sqlite-VERSION.jar com.example.mcp.sqlite.util.EncryptPassphrase "your-plain-passphrase"

Uso

Usa la frase de contraseña cifrada (con el prefijo encrypted:) en tu configuración:

En macOS con Keychain (recomendado):

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"encrypted:<encrypted-passphrase>\"}"
      ]
    }
  }
}

Nota: no se necesita la sección env: la clave se carga automáticamente desde macOS Keychain.

Con variable de entorno (multiplataforma):

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"encrypted:<encrypted-passphrase>\"}"
      ],
      "env": {
        "MCP_SQLITE_ENCRYPTION_KEY": "<your-encryption-key>"
      }
    }
  }
}

Notas de seguridad importantes:

• La clave de cifrado DEBE estar disponible (macOS Keychain o variable de entorno MCP_SQLITE_ENCRYPTION_KEY)

• El servidor detecta automáticamente las frases de contraseña cifradas (que empiezan por encrypted:) y las descifra

• Usa PassphraseEncryption.generateKey() para generar claves seguras (256 bits / 32 bytes)

• AES-256-GCM proporciona cifrado autenticado

• Las claves débiles se rechazan automáticamente

Herramientas disponibles

list_tables

Enumera todas las tablas de la base de datos. De forma predeterminada solo devuelve los nombres de las tablas; con include_columns=true devuelve también los detalles de las columnas.

Parámetros:

• db_path (opcional si se ha configurado): ruta al archivo de la base de datos

• passphrase (opcional si se ha configurado): frase de contraseña de la base de datos

• include_columns (opcional, predeterminado: false): si es true, también se devuelven los detalles de las columnas

Ejemplo:

{
  "name": "list_tables",
  "arguments": {
    "include_columns": true
  }
}

get_table_data

Lee datos de una tabla con filtrado opcional, selección de columnas y paginación.

Parámetros:

• table (obligatorio): nombre de la tabla

• columns (opcional): matriz de nombres de columnas a seleccionar

• filters (opcional): objeto con pares columna-valor para filtrar

• limit (opcional, predeterminado: 200): número máximo de filas

• offset (opcional, predeterminado: 0): desplazamiento para la paginación

Ejemplo:

{
  "name": "get_table_data",
  "arguments": {
    "table": "accounts",
    "columns": ["id", "name", "balance"],
    "filters": {"status": "active"},
    "limit": 50,
    "offset": 0
  }
}

execute_sql

Ejecuta sentencias SQL arbitrarias (SELECT, INSERT, UPDATE, DELETE, DDL).

Advertencia de seguridad: esta herramienta ejecuta SQL sin parametrizar. Úsala solo con SQL confiable o asegúrate de que se realice una validación y desinfección adecuadas antes de llamar a esta herramienta. Para operaciones más seguras, usa las otras herramientas (get_table_data, insert_or_update, delete_rows), que utilizan consultas parametrizadas.

Parámetros:

• sql (obligatorio): sentencia SQL a ejecutar

Ejemplo:

{
  "name": "execute_sql",
  "arguments": {
    "sql": "SELECT COUNT(*) FROM transactions WHERE amount > 1000"
  }
}

insert_or_update

Realiza operaciones UPSERT (INSERT o UPDATE en caso de conflicto).

Parámetros:

• table (obligatorio): nombre de la tabla

• primary_keys (obligatorio): matriz de nombres de columnas de clave primaria

• rows (obligatorio): matriz de objetos de fila para insertar/actualizar

Ejemplo:

{
  "name": "insert_or_update",
  "arguments": {
    "table": "accounts",
    "primary_keys": ["id"],
    "rows": [
      {"id": 1, "name": "Account 1", "balance": 1000.0},
      {"id": 2, "name": "Account 2", "balance": 2000.0}
    ]
  }
}

delete_rows

Elimina filas de una tabla según filtros.

Parámetros:

• table (obligatorio): nombre de la tabla

• filters (obligatorio): objeto con pares columna-valor para filtrar

Ejemplo:

{
  "name": "delete_rows",
  "arguments": {
    "table": "transactions",
    "filters": {"status": "cancelled"}
  }
}

get_table_schema

Recupera información detallada del esquema de una tabla (columnas, índices, claves foráneas, restricciones).

Parámetros:

• table (obligatorio): nombre de la tabla

Ejemplo:

{
  "name": "get_table_schema",
  "arguments": {
    "table": "accounts"
  }
}

list_indexes

Enumera todos los índices de una tabla.

Parámetros:

• table (obligatorio): nombre de la tabla

Ejemplo:

{
  "name": "list_indexes",
  "arguments": {
    "table": "accounts"
  }
}

Modo de depuración

El servidor admite salida de depuración opcional mediante la variable de entorno MCP_DEBUG. Cuando está habilitada, la información de depuración detallada se escribe en stderr (no en stdout, para cumplir con los requisitos del protocolo MCP).

Habilitar el modo de depuración:

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
      ],
      "env": {
        "MCP_DEBUG": "true"
      }
    }
  }
}

La salida de depuración incluye:

• Información de inicio del servidor (versión de Java, sistema operativo, argumentos)

• Detalles del análisis de configuración

• Información de procesamiento de solicitudes

• Tamaños y estructuras de las respuestas

• Detalles de la conexión a la base de datos

Nota: la salida de depuración está deshabilitada de forma predeterminada para mantener los registros limpios. Habilítala solo al solucionar problemas.

Perfil de cifrado predeterminado

El servidor utiliza los valores predeterminados de SQLCipher 4 de forma predeterminada:

• cipher_page_size: 4096

• kdf_iter: 256000

• cipher_hmac_algorithm: HMAC_SHA512

• cipher_kdf_algorithm: PBKDF2_HMAC_SHA512

• cipher_use_hmac: ON

• cipher_plaintext_header_size: 0

Estos ajustes coinciden con los valores predeterminados que usan herramientas como "DB Browser for SQLite" con SQLCipher 4.

Desarrollo

Consulta DEVELOPMENT.md para la configuración de desarrollo, compilación, pruebas y estructura del proyecto.

Consideraciones de seguridad

Seguridad general

• Frases de contraseña: Las frases de contraseña solo se almacenan en memoria y nunca se registran

• Frases de contraseña cifradas: Use frases de contraseña cifradas con AES-256-GCM para almacenarlas en archivos de configuración (consulte la sección Frases de contraseña cifradas)

• Memoria: Tenga en cuenta que las frases de contraseña descifradas permanecen en memoria como cadenas de Java (inmutables). Para máxima seguridad, considere usar arreglos char[], aunque esto no está implementado actualmente.

• Transporte: Use canales de transporte seguros (por ejemplo, sesiones cifradas) al acceder al servidor de forma remota

• Permisos de archivo: Asegúrese de que los archivos de base de datos tengan permisos de sistema de archivos adecuados

Mejores prácticas de seguridad

1. Use frases de contraseña cifradas con cifrado AES-256-GCM

2. Genere claves seguras usando PassphraseEncryption.generateKey() (256 bits / 32 bytes)

3. Almacene las claves de cifrado de forma segura: Use el Llavero de macOS (recomendado en macOS) o un almacenamiento seguro de secretos

4. Nunca almacene la clave de cifrado y la frase de contraseña cifrada en el mismo archivo de configuración - Use scripts contenedores o variables de entorno para cargar la clave de forma segura (consulte DOCKER_CONFIGURATION.md para más detalles)

5. Rote las claves periódicamente - al rotarlas, vuelva a cifrar todas las frases de contraseña con la nueva clave

6. Use claves diferentes para distintos entornos (desarrollo, pruebas, producción)

7. Nunca envíe claves o frases de contraseña cifradas al control de versiones

8. Restrinja los permisos de archivo en los archivos de configuración que contengan secretos (chmod 600)

Solución de problemas

Depuración de problemas de comunicación del servidor MCP

El servidor MCP incluye amplias funciones de depuración para ayudar a diagnosticar problemas de comunicación.

Visualización de registros

En clientes MCP:

• Revise la salida de registros de su cliente (por ejemplo, Cursor: panel de salida → "MCP Logs")

• Toda la salida de depuración se escribe en stderr

Pruebas manuales: Ejecute: ./build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite --args '{"db_path":"/path/to/db.sqlite","passphrase":"secret"}' 2>&1 | tee mcp-debug.log

Problemas comunes de comunicación

1. El servidor no se inicia

• Síntoma: No se ven registros, el servidor no responde

• Depuración: Revise los registros de inicio:

  • Se registra la versión de Java

  • Se registran los argumentos

  • Se registra el análisis de configuración

• Solución:

  • Verifique que Java esté instalado correctamente

  • Revise la configuración de MCP (mcp.json)

  • Revise las rutas en los campos command y args

2. Errores de análisis JSON

• Síntoma: "Error de análisis" en los registros

• Depuración: El servidor registra:

  • Los primeros 500 caracteres del JSON recibido

  • La excepción exacta con el seguimiento de pila

• Solución:

  • Revise la estructura JSON en la configuración de MCP

  • Asegúrese de que el JSON esté correctamente escapado

  • Verifique que todos los campos requeridos estén presentes

3. Respuestas faltantes o incorrectas

• Síntoma: Las solicitudes no se responden o se producen tiempos de espera

• Depuración: El servidor registra:

  • Cada solicitud recibida con ID y método

  • Tamaño y estado de la respuesta

  • Estado de vaciado después de escribir

• Solución:

  • Verifique si STDOUT está disponible (registrado al inicio)

  • Revise el tamaño de la respuesta (las respuestas muy grandes pueden causar problemas)

  • Verifique que el vaciado se haya realizado correctamente

4. Solicitudes no válidas

• Síntoma: Errores de "Solicitud no válida"

• Depuración: El servidor registra:

  • Campos faltantes (por ejemplo, method, id)

  • Discrepancias de versión JSON-RPC

  • Parámetros no válidos

• Solución:

  • Asegúrese de que todas las solicitudes cumplan con el estándar JSON-RPC 2.0

  • Verifique que los campos method e id estén presentes

  • Revise la estructura de los parámetros

5. Problemas de conexión a la base de datos

• Síntoma: Errores de "Error de base de datos"

• Depuración: El servidor registra:

  • Rutas de base de datos utilizadas (predeterminada vs. anulada)

  • Estado de la frase de contraseña (cifrada/descifrada)

  • Configuración de CipherProfile

• Solución:

  • Revise la ruta de la base de datos en los registros

  • Verifique que la frase de contraseña se haya descifrado correctamente

  • Revise la configuración de CipherProfile

Funciones de depuración en detalle

El servidor registra automáticamente:

• Información de inicio:

  • Versión de Java y Java Home

  • Información del sistema operativo

  • Número y contenido de los argumentos

  • Estado del análisis de configuración

• Procesamiento de solicitudes:

  • Cada solicitud recibida con número y longitud

  • Validación JSON-RPC

  • Llamadas a métodos con parámetros

  • Tamaño y estado de la respuesta

• Manejo de errores:

  • Información detallada de excepciones con seguimientos de pila

  • Códigos de error JSON-RPC según la especificación

  • Respuestas de error con datos de depuración adicionales

• Operaciones de base de datos:

  • Configuraciones utilizadas (predeterminada vs. anulada)

  • Consultas SQL (primeros 100 caracteres)

  • Tamaños de resultados y filas afectadas

No se puede abrir la base de datos

• Verifique que la frase de contraseña sea correcta

• Compruebe que la base de datos use los valores predeterminados de SQLCipher 4 (o configure un perfil de cifrado personalizado)

• Asegúrese de que la ruta del archivo de base de datos sea correcta y accesible

• Revise los registros: El servidor registra información detallada sobre el descifrado de la frase de contraseña y la ruta de la base de datos

Problemas de conexión

• Verifique que Java esté instalado: java -version

• Compruebe que JAVA_HOME esté configurado correctamente en la configuración de MCP

• Revise los registros de su cliente MCP para ver mensajes de error detallados

Tablas FTS (búsqueda de texto completo)

El servidor maneja automáticamente las tablas virtuales FTS que pueden no tener metadatos accesibles. Estas tablas aparecerán con listas de columnas vacías.

Licencia

Licenciado bajo la Licencia Apache, Versión 2.0. Consulte LICENSE para más detalles.

Licencias de terceros

• sqlite-jdbc-crypt (Licencia Apache 2.0) - Controlador JDBC de SQLite con soporte de cifrado

  • Fuente: https://github.com/Willena/sqlite-jdbc-crypt

• Gson (Licencia Apache 2.0) - Biblioteca JSON para Java

  • Fuente: https://github.com/google/gson

• JUnit Jupiter (Licencia Pública de Eclipse 2.0) - Marco de pruebas

  • Fuente: https://junit.org/junit5/

Consulte NOTICE para obtener información detallada de atribución.

Agradecimientos

• sqlite-jdbc-crypt - Controlador JDBC de SQLite con soporte de cifrado

• Model Context Protocol - Especificación MCP

Contribuciones

¡Las contribuciones son bienvenidas! No dude en enviar una solicitud de extracción. Consulte CONTRIBUTING.md para obtener pautas.

Soporte

Para problemas, preguntas o contribuciones, abra un problema en GitHub.

Invítame un café

¿Te gusta esta integración? ¡Siéntete libre de invitarme un café! Tu apoyo me ayuda a seguir trabajando en funciones interesantes.