DBine

DBine

DBine es un gestor de bases de datos de escritorio multi-motor de AddLayer. Una sola aplicación funciona con bases de datos relacionales, analíticas, de documentos, clave-valor, de grafos, de series temporales y de búsqueda. Funciona en Windows, macOS y Linux.

Está construido con Tauri 2, un núcleo en Rust y una interfaz de usuario en Vue 3 + Element Plus. La interfaz es un espacio de trabajo estilo VS Code. Cada motor es su propio crate y las consultas se organizan dentro de cada base de datos.

Qué hace

Explorador y conexiones

• Árbol por conexión y por base de datos. El primer nodo de cada base de datos es Consultas, con las consultas guardadas de esa base de datos. De esta manera, las pestañas sueltas no se acumulan. Debajo vienen los objetos propios del motor: tablas, vistas, rutinas, colecciones, índices, claves, nodos…
• Caché del explorador. Cuando se abre una conexión, las bases de datos, los objetos y las columnas aparecen al instante con lo que había la última vez, y el servidor los actualiza (el servidor siempre gana). Solo almacena nombres y estructura. Detalles: docs/explorer-cache.md.
• Carpetas y grupos, por ejemplo por cliente o por entorno. Pueden estar anidadas y tener color, y los servidores se mueven entre ellas arrastrándolos.
• Importar conexiones desde DBeaver, DbGate, DataGrip / JetBrains, Azure Data Studio y SSMS, o pegando URLs de conexión. DBine lee los archivos de esas herramientas, muestra lo que encontró y guarda las que elijas. Las contraseñas van directamente al llavero del sistema, sin pasar por la interfaz. Desde DBeaver y DbGate, el túnel SSH se incluye.
• Túneles SSH: cualquier conexión a un motor de red puede pasar por un servidor SSH, incluso a través de una cadena de bastiones, con contraseña, clave privada o el agente SSH. La huella digital de cada servidor se verifica contra known_hosts o se confirma la primera vez. La contraseña y la frase de contraseña de la clave nunca van al archivo de estado ni a los registros. Todo lo que se abre en una conexión comparte un único túnel, que se reabre solo si se cae. Detalles: docs/ssh-tunnels.md.
• Menú contextual de la base de datos:
  • nueva consulta, nueva tabla con un diseñador (y modificar una existente), nuevos objetos desde plantillas;
  • diagrama ER, generar script, exportar o importar la base de datos, ejecutar un archivo de script;
  • comparar esquemas, migrar, clonar o sincronizar, y Profiler;
  • crear o eliminar la base de datos, copiar su nombre o el del servidor;
  • crear una base de datos con las opciones avanzadas de cada motor (intercalación, archivos, réplicas, retención…), con el script a la vista. Detalles: docs/create-databases.md.
• Crear y eliminar esquemas, con su propietario y permisos en el mismo script, que se revisa antes de ejecutarlo. Detalles: docs/schemas.md.
• Conexiones de solo lectura: DBine bloquea todo lo que no sea una lectura.

Monitor y Profiler

• Monitor del servidor, haciendo clic derecho en la conexión: CPU, memoria, sesiones y actividad, en los motores que los exponen.
• Procesos, en el Monitor: la lista en vivo de sesiones y consultas en ejecución, con filtros, bloqueos resaltados y la opción de cancelar una consulta o terminar una sesión. Detalles: docs/processes.md.
• Profiler, haciendo clic derecho en una base de datos: una pestaña con todas las consultas que cualquier cliente ejecuta en esa base de datos, en vivo, como el Profiler de SQL Server. Para cada una muestra la hora, la duración, el texto, la base de datos, el usuario, el cliente, las filas y el error, con filtros y la opción de abrirla en una consulta.
  • Si el motor registra cada consulta (Eventos Extendidos en SQL Server, system.profile en MongoDB, historiales de consultas o registros), DBine lee lo que es nuevo cada segundo. Si solo muestra lo que se está ejecutando actualmente, muestrea cada 100 ms, y la pestaña advierte que las consultas más cortas pueden no aparecer.
  • Si el motor necesita que algo esté habilitado para capturar, DBine lo habilita al inicio, lo muestra en amarillo y lo restaura al detener o al cerrar. En conexiones de solo lectura no cambia nada en el servidor.
  • CPU, lecturas y escrituras de cada consulta, en los motores que reportan esas cifras y en su propia unidad (páginas, bloques, filas, bytes, documentos o claves). Cuando se agrupan consultas idénticas, se muestran el promedio, el mínimo, el p95 y el máximo, y también se pueden usar para filtrar.
  • Detalles por motor: docs/engine-support.md.

Editor y resultados

• Consultas guardadas. Se guardan solas mientras escribes. Cada pestaña tiene su propia sesión, por lo que los SETs, las tablas temporales y las transacciones persisten entre ejecuciones.
• Pestañas de vista previa, como en VS Code. Hacer doble clic en una pestaña muestra su consulta u objeto en el árbol, y "Ir a la base de datos" abre el menú de esa base de datos.
• Varias ventanas en la misma instancia, desde el Dock, la barra de tareas o el menú. Comparten conexiones, consultas y configuraciones. Detalles: docs/windows.md.
• Editor CodeMirror 6, con el dialecto de cada motor y la autocompletación de tablas y columnas. Ejecuta la selección o la declaración bajo el cursor, y se puede cancelar con el mecanismo nativo de cada motor.
• Ejecución de scripts en cada motor: el script se divide declaración por declaración respetando los terminadores de cada motor, los mensajes del servidor llegan en vivo y en orden, los errores vienen con su código y línea, hay transacciones manuales por pestaña donde el motor las tiene, y cancelar mantiene la sesión. Detalles: docs/script-execution.md.
• Edición de celdas: cuando se modifica una celda, el código de actualización se genera en el lenguaje del motor. DBine no lo ejecuta: lo agrega a la consulta y tú decides.
• Agregar filas y documentos: las nuevas filas se agregan a los cambios pendientes junto con las ediciones y eliminaciones, y el código de inserción sale en el lenguaje de cada motor (SQL, comandos Redis, insertMany, Cypher…). Los motores de documentos agregan uno o varios documentos desde un editor JSON, también en colecciones vacías.
• Cuadrícula virtualizada con varios resultados por ejecución, mensajes y un visor de celdas (con JSON formateado).
• Filtros de columna en los datos de una tabla (valores, rangos, nulos, texto). Se aplican en el servidor, con el filtro propio de cada motor.
• Copiar resultados en 10 formatos: con o sin encabezados, CSV, JSON, JSON Lines, YAML, INSERT, UPDATE, inserciones de Mongo… El formato predeterminado para ⌘C es configurable.
• Exportar resultados a CSV (con ,, con ; o para Excel), TSV, JSON, JSONL, SQL, XLSX y XML. La exportación vuelve a ejecutar la consulta completa en streaming, por lo que no se limita a las filas en pantalla.
• Gráficos de resultados con Apache ECharts.
• Vista de árbol JSON de resultados, diseñada para bases de datos de documentos y disponible en cada motor: despliega campos anidados y columnas JSON, con búsqueda en claves y valores, tipos por campo y matrices grandes agrupadas.
• Planes de ejecución gráficos, al estilo de Management Studio: estimados, reales o ambos, con zoom y desplazamiento.
• Buscar en la base de datos: un texto en nombres de objetos, nombres de columnas y el código de vistas, rutinas y disparadores, con resultados a medida que avanza. Detalles: docs/search.md.
• Ejecutar en varias bases de datos: el código del editor en varias bases de datos de una conexión a la vez, con los resultados juntos en una sola cuadrícula con una columna base. Detalles: docs/multi-database-queries.md.
• Calidad del código: el editor marca consultas lentas, resultados que probablemente no son los esperados y cambios que afectan más filas de las previstas, con las reglas de cada familia de motores, sin consultar la base de datos. Detalles: docs/code-quality.md.
• Constructor de consultas: construye un SELECT (o su equivalente CQL) en un lienzo con tablas, uniones, agregaciones, ordenamiento y filtros, con el SQL del motor. Detalles: docs/query-builder.md.
• Optimizar consulta: reescrituras equivalentes por reglas y por IA, índices sugeridos desde el plan y una comparación de solo lectura de tiempos y resultados. Detalles: docs/query-optimizer.md.

Diseño y estructura

• Diseñador de tablas adaptado a cada motor. En Mongo diseña colecciones, con validación; en cada motor usa sus propios tipos, identidades, índices y claves.

• Diagrama ER de la base de datos:

  • con relaciones, búsqueda y filtrado por uno o varios esquemas;
  • con un modo "solo claves", minimapa y exportación a SVG o PNG;
  • con diseño automático que maneja cientos de tablas.

• Generador de scripts para la base de datos, eligiendo qué incluir: DROP, CREATE, índices, claves foráneas, vistas y rutinas, datos y disparadores. Sale en el orden correcto para restaurar, con los ajustes de cada motor (por ejemplo, IDENTITY_INSERT en SQL Server o resincronizar secuencias en PostgreSQL).

• Migrar, clonar y sincronizar bases de datos: "Migrar…" en el menú de una base de datos mueve sus tablas y datos a otra base de datos, incluso de otro motor. Solo se habilitan los modos que funcionan para ese par de motores:

  • Migrar (convertir), entre cualquier par de motores: convierte tipos, valores predeterminados, claves, índices y nombres, muestra un informe de cada cambio y copia los datos.
  • Clonar, entre bases de datos del mismo motor: deja el destino idéntico al origen, con esquemas, tipos, particiones, índices, restricciones, secuencias, vistas, rutinas y disparadores. En SQL Server y Azure SQL, y en PostgreSQL, TimescaleDB, KingbaseES, AlloyDB, Cloud SQL, Aurora, EDB y Fujitsu.
  • Sincronizar, en tablas que ya existen en el destino: compara por clave e inserta, actualiza y elimina solo las filas que difieren, en una transacción por tabla. En SQL Server y Azure SQL, y en PostgreSQL, TimescaleDB, YugabyteDB, KingbaseES, AlloyDB, Cloud SQL, Aurora, EDB y Fujitsu, con PostgreSQL 11 o posterior.
  • La copia usa la carga masiva nativa de cada motor (INSERT BULK, COPY binario, LOAD DATA, Appender de DuckDB…) o INSERT por lotes donde no la hay. Mueve varias tablas a la vez con memoria limitada y muestra el progreso y las filas por segundo de cada una. El origen se abre en solo lectura y los datos llegan sin pérdida.
  • Si la aplicación se cierra a mitad de camino, la ejecución se reanuda más tarde sin copiar nuevamente las tablas ya terminadas.
  • Migraciones guardadas: cada base de datos tiene un nodo "Migraciones" con las iniciadas desde ella. La configuración se guarda sola y viaja con la sincronización en la nube, y cada ejecución se mantiene en su historial para que pueda reabrirse, reanudarse o repetirse.

  Detalles: docs/migration.md.

• Comparar esquemas: "Comparar esquemas…" en el menú de una base de datos muestra dos bases de datos lado a lado, al estilo de WinMerge. Pueden estar en conexiones diferentes, e incluso en motores diferentes.

  • Compara tablas, vistas, procedimientos, funciones y disparadores. Resalta lo que difiere en columnas, índices, claves foráneas y la clave primaria, y las líneas de código que difieren.
  • Con las flechas → y ←, los cambios se pasan de un lado al otro, por objeto o por columna, con deshacer.
  • Un objeto también se puede eliminar de un lado sin pasarlo desde el otro, y antes de ejecutar ves de qué depende.
  • "Sincronizar" genera el script del motor de ese lado (CREATE, ALTER, DROP) en el orden correcto, y advierte si algo puede perder datos o fallar. Se abre como una consulta o se ejecuta con confirmación. Detalles: docs/schema-compare.md.

• Comparar datos: compara las filas de dos tablas o colecciones, en la misma conexión, en conexiones diferentes o en motores diferentes. Las empareja por la clave primaria, o por las columnas que elijas, y compara los valores por lo que valen y no por cómo los devuelve cada motor.

  • Muestra las filas que difieren, con cada valor marcado, y las que están solo en un lado. Para cada fila eliges qué camino toma: actualizar, insertar o eliminar. Las eliminaciones nunca se eligen automáticamente.
  • Genera un script por lado que cambia, en el lenguaje de su motor, que se puede copiar, abrir en una consulta o ejecutar. Luego compara de nuevo.
  • Advierte si las dos tablas no son iguales, si hay claves duplicadas o si una supera las 200.000 filas. Las conexiones de solo lectura rechazan el script.
  • Compara en todos los motores. Aplicar los cambios depende de lo que el destino permita escribir: Drill, por ejemplo, no tiene INSERT, UPDATE o DELETE.

  Detalles: docs/data-compare.md.

• Clonar tabla: desde el explorador, una tabla, colección o índice se clona junto al original, con un nombre que lleva la fecha y la hora que se puede cambiar.

  • Copia columnas, clave primaria, restricciones, índices y claves foráneas, y los datos con el motor de transferencia, preservando las identidades. También puede clonar solo la estructura.
  • El clon sale exacto o no se crea: si algo no se puede copiar de forma idéntica, o si lo detienes, lo que se creó se elimina. La tabla original nunca se toca.
  • Está disponible en todos los motores con tablas o colecciones que tengan filas propias. No en motores de grafos o clave-valor, ksqlDB, CouchDB o InfluxDB 2 y 3. Detalles: docs/engine-support.md.

• Importar CSV, TSV, JSON, JSONL, XLSX y XML en una tabla nueva o existente, con mapeo de columnas.

• Ejecutar un archivo de script grande en partes, por ejemplo para restaurar un volcado.

• Datos de prueba: llena una tabla con filas inventadas pero plausibles, respetando claves, longitudes y claves foráneas. Detalles: docs/test-data.md.

• Documentar la base de datos: un diccionario de datos en HTML o Markdown, con tablas, claves, índices, código de rutinas, dependencias y un diagrama entidad-relación. Detalles: docs/database-docs.md.

• Subconjunto de datos: copia algunas filas de una tabla a otra base de datos, con las filas padre que necesitan, y enmascara datos personales. Detalles: docs/data-subset.md.

Administración

• Usuarios y permisos: una pestaña con los usuarios y roles del servidor (o de la base de datos, donde son por base de datos). Para cada uno muestra sus roles y sus permisos, directos o heredados de un rol, incluidos los denegados.

  • Los usuarios y roles se crean, las contraseñas se cambian, el inicio de sesión se habilita o deshabilita, y los permisos sobre la base de datos, un esquema o un objeto se otorgan o revocan.
  • Cada cambio se convierte en un script del motor que se revisa antes de ejecutarlo. La contraseña no aparece en la vista previa y estos scripts no se guardan en el historial.
  • Está disponible en la gran mayoría de los motores. Los que no tienen usuarios propios no lo tienen, como SQLite, DuckDB o DynamoDB. Detalles: docs/users-and-permissions.md.

• Acciones según los permisos del usuario: antes de ofrecer copias de seguridad, restauraciones, el Profiler, terminar sesiones, crear o eliminar bases de datos o gestionar usuarios, DBine pregunta al servidor si el usuario conectado puede hacerlo. Si no puede, la acción aparece deshabilitada y dice qué permiso falta. Si el motor no permite saberlo con certeza, permanece habilitada.

• Copias de seguridad, en una pestaña por base de datos:

  • DBine copia en todos los motores: un script local con la estructura y, si quieres, los datos, con su historial en esta máquina, que se restaura en la misma base de datos u otra;
  • copias de seguridad del servidor donde el motor las tiene (SQL Server, Oracle, SAP HANA, ClickHouse, Snowflake, BigQuery, Elasticsearch, Redis, entre otros), con su historial y el script para hacer, restaurar o eliminar una copia de seguridad, que se revisa antes de ejecutarlo.

  Detalles: docs/backups.md.

• Tareas programadas: scripts, exportaciones, comparaciones de esquemas, copias de seguridad, documentación de bases de datos y correos electrónicos que se ejecutan solos con DBine cerrado, con una notificación del sistema, historial y aprobación previa de cualquier cosa que cambie datos. Detalles: docs/scheduled-tasks.md.

• Comprobación de estado: revisa una base de datos y enumera lo que merece atención por gravedad, con las comprobaciones propias de cada motor y scripts de corrección que se revisan antes de ejecutarlos. Detalles: docs/health-check.md.

• Propiedades de la base de datos: muestra lo que el motor informa sobre una base de datos y cambia lo que permite, con el script y las advertencias a la vista. Detalles: docs/database-properties.md.

Biblioteca de scripts

Los scripts reutilizables de un DBA ("Reindexar una tabla", "Sesiones bloqueadas"…) se guardan en su propia vista, con la ⭐:

• Por motor, no por base de datos: cada script pertenece a uno o más motores, para que un script de MongoDB no se mezcle con uno de SQL Server.
• Al abrirlo, se copia en una consulta de la base de datos activa y pide su {{parameters}}, con sugerencias de las tablas de esa base de datos.
• Organización: carpetas y búsqueda.
• Importar y exportar: trae la carpeta de archivos .sql que ya tienes de una vez, y la exporta de la misma manera.

Detalles: docs/library.md.

Sincronización en la nube

Una copia de seguridad de conexiones, carpetas, consultas, preferencias y contraseñas. Se almacena cifrada de extremo a extremo con una frase de contraseña elegida por el usuario (XChaCha20-Poly1305 + Argon2id) y permanece en su propia cuenta:

• Google Drive, en la carpeta privada de la aplicación;
• OneDrive, en la carpeta de la aplicación;
• o cualquier carpeta, como iCloud o Dropbox.

Se sincroniza solo, resuelve conflictos sin perder datos y permite recuperar todo en otra máquina. AddLayer no tiene servidores para esto y nunca ve los datos. Detalles: docs/sync.md.

Asistente de IA

Un chat en la barra lateral derecha (⌘I). Escribe consultas, explica o corrige la del editor y responde sobre la estructura de la base de datos.

• Nunca ejecuta nada. Su código se añade a la consulta abierta, o la reemplaza al corregirla, y el usuario decide si ejecutarlo.
• Usa lo que hay en la máquina:
  • el modelo integrado (llama.cpp con Qwen2.5-Coder 3B o 7B), que se ejecuta localmente y se descarga solo una vez, la primera vez que se usa;
  • Ollama o LM Studio;
  • Claude Code o Codex con la cuenta del usuario, sin herramientas.
• Nunca envía filas de datos. Como contexto recibe el motor, la estructura y el editor.

Detalles: docs/ai-assistant.md.

Servidor MCP

DBine puede funcionar como un servidor MCP local, para que asistentes como Claude Code, Codex, Cursor, Claude Desktop, VS Code o Windsurf trabajen con tus conexiones mientras DBine está abierto. Viene desactivado.

• Cuatro niveles por conexión: Deshabilitado (el asistente no la ve), Esquema (solo estructura, sin datos), Lectura (también filas de muestra, consultas de solo lectura y planes estimados) y Escritura. El nivel predeterminado es Esquema, y las conexiones etiquetadas prod o de solo lectura nunca van más allá de Lectura.
• Cada escritura se aprueba: DBine pasa al frente y muestra el cliente, la conexión, la base de datos y el código exacto para aprobarlo o rechazarlo. Si no respondes en 2 minutos, se rechaza y no se ejecuta nada.
• Un token por cliente, revocable por separado. DBine escucha solo en esta máquina y rechaza las solicitudes que provienen de páginas del navegador.
• Registro de actividad local con las últimas 10.000 llamadas, filtrable por cliente o por conexión. No almacena contraseñas ni secretos.

Detalles: docs/mcp.md.

Seguridad

• Las contraseñas y otros secretos se almacenan cifrados (XChaCha20-Poly1305) en un archivo separado, con una clave aleatoria que vive en el llavero del sistema (Keychain, Credential Manager, Secret Service). Es un solo elemento del llavero para toda la aplicación: el sistema pide permiso una vez, no una vez por conexión. Nunca van al archivo de estado ni a los registros.
• El estado local es un archivo SQLite en la carpeta de configuración de la aplicación.

Actualizaciones

• Se actualiza solo en macOS, Windows y con el AppImage de Linux: descarga la nueva versión, verifica su firma y se reinicia para terminar, sin interrumpir las ejecuciones en segundo plano sin preguntar. Con los paquetes .deb y .rpm, notifica y ofrece la página de la versión.

Detalles: docs/updates.md.

Motores

Cada motor es un crate en crates/drivers/. Cada nueva función tiene que funcionar en todos ellos. Las excepciones, con su motivo, están en docs/engine-support.md.

Familia	Motores
Relacional	SQL Server · PostgreSQL · CockroachDB · YugabyteDB · TimescaleDB · Greenplum · KingbaseES · Denodo · MySQL · MariaDB · TiDB · OceanBase · SingleStore · SQLite · libSQL / Turso · Oracle · Oracle Autonomous · Firebird · SAP HANA · Aurora DSQL · Cloud Spanner · ODBC (Db2, Sybase ASE, SQL Anywhere, Informix y más)
Analítico	DuckDB · archivos CSV / Parquet / JSON · ClickHouse · Trino · Presto · Starburst · BigQuery · Athena · Snowflake · Databricks · Redshift · StarRocks · Doris · Databend · Hive · Impala · Drill · Dremio · Calcite Avatica · Flight SQL · Teradata · Vertica · Exasol · Netezza · Ocient
Documento	MongoDB · CouchDB · Couchbase · Azure Cosmos DB
Clave-valor	Redis · Valkey · Dragonfly · DynamoDB · etcd
Grafo	Neo4j · Memgraph · Amazon Neptune · OrientDB
Columna ancha	Cassandra · ScyllaDB · Amazon Keyspaces · Phoenix
Series temporales	InfluxDB 1/2/3 · IoTDB · GreptimeDB · TDengine
Búsqueda	Elasticsearch · OpenSearch · Solr · Manticore
Streaming	ksqlDB · Timeplus

Ningún controlador necesita bibliotecas del proveedor para que la aplicación se inicie:

• Oracle usa un cliente de Rust puro.
• ODBC carga el administrador de controladores solo cuando se usa.
• Los ajustes preestablecidos de ODBC sí necesitan el controlador del proveedor instalado para conectarse.
• DuckDB no está incluido en la aplicación. La primera vez que te conectas, DBine descarga la biblioteca oficial, con la versión fijada y verificada por sha256, y el explorador muestra el progreso ("Descargando DuckDB…"). Lo mismo ocurre con el motor del asistente de IA. De esta manera, el ejecutable pesa mucho menos.

Apoya el proyecto

DBine es gratuito y seguirá siéndolo. Si te resulta útil, puedes apoyarlo con lo que quieras, una vez o cada mes, desde Buy Me a Coffee. Es un apoyo, no una licencia: la aplicación funciona igual.

Descarga

Los instaladores están en Releases:

• Windows: .msi o -setup.exe.
• macOS: .dmg, en versión Apple Silicon o Intel.
• Linux: .AppImage, .deb o .rpm.

Los binarios aún no están firmados por Apple o Microsoft:

• macOS: la primera vez avisa que no puede verificar al desarrollador. Abre Configuración del Sistema › Privacidad y seguridad y haz clic en "Abrir de todos modos". También se puede hacer desde la terminal: xattr -dr com.apple.quarantine /Applications/DBine.app.
• Windows: SmartScreen puede pedir "Más información" › "Ejecutar de todos modos".

Compilar

Requisitos

• Rust estable y Node.js 20 o posterior.
• Un compilador de C (Xcode Command Line Tools en macOS, Visual Studio Build Tools en Windows, build-essential en Linux). llama.cpp y DuckDB ya no se compilan: se descargan la primera vez que se usan.
• Solo Linux: sudo apt install libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev libxdo-dev.

npm install --prefix web
cargo install tauri-cli --version "^2"

Desarrollo

cargo tauri dev          # the app with hot reload
cargo test --workspace   # unit tests

macOS: evitar que el llavero pida permiso en cada recompilación. Las compilaciones de desarrollo están firmadas "ad hoc" y cambian de identidad en cada compilación, por lo que macOS vuelve a preguntar por cada contraseña guardada. Con un certificado de firma de código llamado DBine Dev en el llavero de inicio de sesión (con autofirma es suficiente), cargo run / cargo tauri dev firman la aplicación con una identidad fija (scripts/dev-sign-run.sh, configurada en .cargo/config.toml). Después del primer "Permitir siempre", no vuelve a preguntar. Para crear el certificado, una vez por máquina:

openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 3650 -nodes -subj "/CN=DBine Dev" \
  -addext "keyUsage=critical,digitalSignature" -addext "extendedKeyUsage=critical,codeSigning" -addext "basicConstraints=critical,CA:false"
openssl pkcs12 -export -inkey key.pem -in cert.pem -name "DBine Dev" -out dev.p12 -passout pass:dbine-dev
security import dev.p12 -k ~/Library/Keychains/login.keychain-db -P dbine-dev -T /usr/bin/codesign
rm key.pem cert.pem dev.p12

Sin el certificado, la aplicación sigue funcionando, solo que sin una firma fija.

Instaladores

Cada sistema compila sus propios instaladores:

Sistema	Comando	Salida en target/<target>/release/bundle/
macOS Apple Silicon	cargo tauri build --target aarch64-apple-darwin	.app, .dmg
macOS Intel	cargo tauri build --target x86_64-apple-darwin	.app, .dmg
Windows	cargo tauri build --target x86_64-pc-windows-msvc	.msi, -setup.exe
Linux	cargo tauri build --target x86_64-unknown-linux-gnu	.AppImage, .deb, .rpm

Sin --target, compila para la máquina actual y deja los archivos en target/release/bundle/.

Windows desde macOS (el .exe, sin instalador)

brew install llvm
cargo install cargo-xwin
rustup target add x86_64-pc-windows-msvc

./scripts/build-windows-from-mac.sh
# → target/x86_64-pc-windows-msvc/release/dbine.exe

El script ejecuta cargo tauri build --runner cargo-xwin --target x86_64-pc-windows-msvc --no-bundle con dos ajustes para compilar el código C de las dependencias desde el Mac:

• usa LLVM's clang-cl;
• apunta el lld-link de cargo-xwin al rust-lld de rustup.

Acepta la licencia del Windows SDK (XWIN_ACCEPT_LICENSE=1). Los instaladores .msi y .exe se compilan en Windows o en CI.

Cuentas en la nube

Para que el inicio de sesión de Google Drive y OneDrive funcione, los IDs de la aplicación registrada se compilan en:

DBINE_GOOGLE_CLIENT_ID=… DBINE_GOOGLE_CLIENT_SECRET=… DBINE_MICROSOFT_CLIENT_ID=… cargo tauri build

Localmente también pueden ir en un .env en la raíz del repositorio, que git ignora.

Cómo registrarlo: docs/sync.md.

Publicar una versión

.github/workflows/release.yml compila las cuatro variantes en GitHub Actions: Windows x64, macOS Apple Silicon, macOS Intel y Linux x64. Luego publica los instaladores en una versión.

git tag v0.2.0
git push origin v0.2.0

• La versión de la aplicación se toma de la etiqueta.
• Si existen los secretos DBINE_GOOGLE_CLIENT_ID, DBINE_GOOGLE_CLIENT_SECRET y DBINE_MICROSOFT_CLIENT_ID, la compilación los incluye.
• Prueba sin publicar: Actions › release › Run workflow compila todo y deja los instaladores como artefactos.
• El instalador incluye solo el controlador SQLite. Los demás se compilan por separado, se suben a la misma versión, y la aplicación los descarga la primera vez que se usan: docs/on-demand-drivers.md.

Estructura del repositorio

Ruta	Qué hay
crates/dbine-driver	El contrato de controladores (rasgos Driver y Session) y los ayudantes
crates/drivers/<engine>	Un crate por motor o familia de protocolos
crates/dbine-drivers	El registro de controladores, con una característica por crate
crates/dbine-plugin, crates/dbine-plugin-host	Los controladores como procesos separados, descargados al usarse
crates/dbine-core	El estado local (SQLite), el llavero, exportación e importación
crates/dbine-schema	Conversión de esquemas entre motores y comparación de esquemas
crates/dbine-sync	Sincronización cifrada (Google Drive, OneDrive, carpeta)
crates/dbine-ai	El asistente de IA (modelo integrado, Ollama, Claude Code, Codex, LM Studio)
src-tauri	Los comandos de Tauri
web	La interfaz de Vue 3

Documentación:

• AGENTS.md: las convenciones y reglas del proyecto.
• docs/drivers.md: cómo añadir un motor.
• docs/on-demand-drivers.md: cómo se descargan los controladores.
• docs/api-commands.md: los comandos del backend.
• docs/engine-support.md: qué soporta cada motor.
• docs/explorer-cache.md: la caché del árbol del explorador.
• docs/schemas.md: crear y eliminar esquemas.
• docs/create-databases.md: crear bases de datos con opciones.
• docs/windows.md: las ventanas, qué almacena cada una y cerrar una ventana o salir.
• docs/schema-compare.md: cómo se comparan y sincronizan dos bases de datos.
• docs/migration.md y docs/schema-conversion.md: migrar a otro motor y cómo se convierten los tipos.
• docs/ai-assistant.md, docs/library.md y docs/sync.md: el asistente de IA, la biblioteca de scripts y la sincronización en la nube.

Las pruebas de integración están en crates/drivers/*/tests/, marcadas como #[ignore]. Leen DBINE_TEST_<ENGINE>_URL y se ejecutan contra contenedores Docker.