t8y2/dbx

This system is a comprehensive desktop database administration and development client that provides a unified interface for connecting to, querying, and managing a wide variety of relational, NoSQL, and key-value data stores. It features a rich set of tools for schema visualization, data editing, and version control, alongside integrated AI assistance and extensibility through a plugin system. The architecture supports both native desktop and web deployments, utilizing a modular driver system to handle diverse database protocols and metadata requirements.

Users can now deploy DBX via 1Panel using the provided Docker Compose configuration and metadata, and developers can spin up reproducible, versioned local instances of databases like ClickHouse, Consul, Elasticsearch, etcd, Kafka, MariaDB, MongoDB, MySQL, and Nacos for verification using the new \deploy/database\ recipes and Make targets.

deploy · high confidence

Users can now connect to Apache Spark (3.4+) via a new Spark agent that reuses the Hive JDBC driver. The driver supports multi-catalog environments (such as Paimon, Lance, and Iceberg) by allowing a \catalog\ parameter in the connection URL to switch context and list tables correctly. It also ensures reliable query execution by capping the Thrift fetch size to 50, preventing errors with large binary or struct columns, and preserves original comments and provider clauses in generated table DDL.

agents/drivers/spark · high confidence

New agents for BigQuery and Trino are now available, enabling users to connect to these databases via JDBC. The BigQuery agent supports metadata operations such as listing databases, schemas, and tables (including constrained queries with filtering and pagination), retrieving column details, and constructing JDBC URLs with authentication parameters. The Trino agent provides similar metadata capabilities, including listing catalogs and schemas, querying table information with constraints, and retrieving column metadata using both JDBC metadata and DESCRIBE fallbacks. Both agents include comprehensive test coverage for their metadata and execution behaviors.

agents/drivers/bigquery, agents/drivers/trino · high confidence

A new Code Snapshot dialog component has been added to the desktop app, allowing users to preview code as an image with customizable appearance (light/dark theme), window controls (traffic lights), and line numbers. Users can export the snapshot as a PNG file or copy it to the clipboard, with UI settings persisted in local storage. Tests verify that toggling these options correctly triggers re-renders and persists the configuration.

apps/desktop/src/components/codeSnapshot · high confidence

Introduces the FieldLineageDialog Vue component, which provides a user interface for analyzing and displaying field-level data lineage. The dialog allows users to filter lineage results by confidence level (certain, likely, possible), search through lineage items, and view SQL snippets with syntax highlighting. It handles the loading of table metadata, view DDLs, and execution history to build a comprehensive lineage graph for a specific column.

apps/desktop/src/components/lineage · high confidence

Introduces a new GBase 8s database agent that supports creating and dropping databases with specific character sets, maps MySQL-compatible column types, and stabilizes connections by resolving and applying the correct database locale via a hardened probe with retry and timeout.

agents/drivers/gbase8s · high confidence

Introduces the Gbase8a agent, enabling users to connect to and manage Gbase8a databases. This implementation provides accurate metadata listing for tables and routines (procedures/functions) by querying the information schema, and ensures that table DDL and object sources (views, procedures, functions) are retrieved using native SHOW CREATE statements to preserve database-specific syntax and clauses.

agents/drivers/gbase8a · high confidence

This change introduces the Apache IoTDB Go client library (v2) into the agents/go-common/iotdb-client-go package, providing the full set of client-side types, RPC session handling, and data-set decoding required to communicate with IoTDB servers. The implementation includes a specific fix for IoTDB 1.3.x compatibility: the \IoTDBRpcDataSet\ now aligns aggregate column values with their names using the server-provided \columnNameIndex\ mapping, ensuring that result sets are correctly ordered even when the server's internal TsBlock column order differs from the SQL SELECT list.

agents/go-common/iotdb-client-go · high confidence

The GoldenDB database driver agent is now available, enabling connection and metadata operations for GoldenDB databases. The agent supports listing databases, schemas, tables, and objects (including tables, views, procedures, and functions), with support for constrained metadata queries including type filtering and pagination. It also provides column metadata including character set and collation information, and properly quotes schema and table identifiers in index metadata SQL.

agents/drivers/goldendb · high confidence

Users can now connect to Google Cloud Spanner via a new JDBC agent. The implementation handles both GoogleSQL and PostgreSQL dialects, correctly mapping type names (e.g., INT64 to bigint), using the appropriate identifier quotes (backticks for GoogleSQL, double quotes for PostgreSQL), and resolving schema nuances such as the empty string schema in GoogleSQL. It also fixes metadata reporting for primary keys, index columns (handling NULL ordinal positions for STORING/INCLUDE columns), and foreign keys (INTERLEAVE parent links).

agents/drivers/spanner · high confidence

A new legacy H2 2.1 driver agent has been added, extending the existing H2Agent class to support older protocol versions. This agent initializes a MultiSessionJsonRpcServer, enabling users to connect using the legacy H2 2.1 driver while maintaining multi-session capabilities.

agents/drivers/h2-legacy · high confidence

Introduces the Kafka admin agent (KafkaAgent) communicating via JSON-RPC, along with two supporting components: a custom InetAddressResolverProvider that can skip reverse DNS lookups for SASL IP brokers, and an insecure TrustManagerFactory that allows connections to skip TLS certificate verification when explicitly configured.

agents/drivers/kafka/src/main · high confidence

The desktop application now supports connecting to MQTT brokers. This change introduces a payload codec in the desktop app that allows users to encode and decode messages in six formats: Plaintext, JSON, Base64, Hex, CBOR, and MsgPack. To support the underlying communication, the project vendors the \rumqttc\ Rust library, providing the asynchronous client, event loop, and MQTT protocol byte handling required for the connection.

apps/desktop/src/lib/mqtt, vendor/rumqttc · high confidence

Users can now connect to Microsoft Access (.accdb/.mdb) database files via the new AccessAgent. The driver supports both standard and encrypted Access files, automatically applying password-based decryption when required. It exposes standard metadata (tables, columns, indexes, foreign keys) and supports query execution with LIMIT/OFFSET and cursor-based pagination.

agents/drivers/access · high confidence

The application now includes a vendorized Pageant transport implementation for Windows, allowing SSH operations to communicate with the Pageant authentication agent. This adds support for connecting via both modern Named Pipes and legacy WM\_COPYDATA messages, with automatic fallback between the two. The implementation handles Windows username resolution (supporting both local accounts and principal names), trims buffer padding in username lookups, and ensures compatibility with Windows 7 by using appropriate Win32 API entry points.

vendor/pageant · high confidence

A new built-in agent driver for InterSystems Caché is now available, enabling users to connect to and query Caché databases via the standard JDBC interface. The driver handles specific data type mappings, ensuring that %Boolean columns are displayed as their stored 1/0 integer values rather than true/false booleans, and that integer values outside the standard Java primitive range are read safely using BigDecimal to prevent overflow errors.

agents/drivers/cache · high confidence

The MySQL driver crate now includes specialized modules for Dolt, Doris, Manticore Search, OceanBase, and StarRocks, enabling support for these MySQL-compatible engines. Dolt support adds branch-aware database listing and system table visibility. Doris and StarRocks gain multi-catalog support with 3-part qualified names and fallback index listing. Manticore Search adds custom object and column property handling. OceanBase adds materialized view classification and query timeout configuration. StarRocks adds materialized view detection and catalog table listing retries.

crates/dbx-driver-mysql · high confidence

The grid component now supports generating self-contained HTML snapshots of selected data, including options to display field names, column types, and details, as well as transposing the view. Users can customize the appearance with light or dark themes, traffic lights, row numbers, and compact modes, with the snapshot supporting export to PNG.

apps/desktop/src/lib/gridSnapshot · high confidence

Users can now connect to and manage OSCAR (Shentong) databases, an Oracle-compatible system, via a new agent driver. This addition enables viewing and editing table structures, as well as viewing source code for views, procedures, functions, triggers, and sequences. The implementation handles OSCAR-specific differences, such as using \SET SEARCH\_PATH\ for schema switching and reading object source code from system views instead of \DBMS\_METADATA\.

agents/drivers/oscar · high confidence

The desktop application now includes a new Azerbaijani language translation. This adds the \az.ts\ locale file and associated Consul-specific translation messages, enabling the user interface to be displayed in Azerbaijani for users who select this language.

apps/desktop/src/i18n/locales · high confidence

The agents module now includes a placeholder directory for the Dameng database driver and a new Gradle wrapper configuration. The wrapper is set to use Gradle version 9.5.0, establishing the build environment for the agents component.

agents/drivers/dameng, agents/gradle · high confidence

The desktop app now provides SQL assistance for Apache Doris and SelectDB connections. This change introduces a generated function catalogue derived from the Apache Doris 2.1 and 3.x SQL manuals, along with TypeScript logic to parse function signatures and map documentation links. Users benefit from improved code completion and semantic diagnostics when writing SQL queries against these database engines, with SelectDB connections leveraging the same Doris capability family via the existing JDBC dialect.

apps/desktop/src/lib/sql/doris · high confidence

Users can now use a new dialog to quickly browse and select open tabs, likely triggered by a keyboard shortcut (e.g., Ctrl+Tab). This new component, TabSwitcherDialog.vue, presents a list of tabs with their titles, connection names, databases, and mode labels, allowing for faster switching between multiple open queries.

apps/desktop/src/components/tabs · high confidence

A new utility module has been introduced to handle selection intents (single, toggle, and range) within ordered lists. This logic enables users to perform shift-select actions to choose multiple sessions in the process list, supporting both contiguous range selection and individual item toggling via modifier keys.

apps/desktop/src/lib/selection · high confidence

The Wry vendor directory now includes a complete Android backend, introducing new Rust bindings and Kotlin classes (such as WryActivity, RustWebView, and RustWebChromeClient) to manage the Android WebView lifecycle, handle IPC, and process custom protocol requests. This addition also brings a custom protocol URI workaround to support non-standard schemes on Android and WebView2, along with an HTML injection mechanism for initialization scripts when native document start scripts are unavailable.

vendor/wry · high confidence

The SQL editor now automatically detects when a selection contains JSON or XML and formats it using dedicated formatters, rather than passing it through the SQL formatter. This prevents corruption of structured documents and ensures they are properly indented and formatted.

apps/desktop/src/lib/sql · high confidence

The Tauri updater plugin now supports downloading and installing updates in the background. This change introduces new IPC commands (\download\, \install\, and \download\_and\_install\) that allow applications to fetch update payloads asynchronously, report progress via events, and perform the installation without blocking the main thread. It also adds configuration options for Windows installers, including specific install modes (Basic UI, Quiet, Passive) and custom arguments.

vendor/tauri-plugin-updater · high confidence

The desktop application now uses a dedicated \tokens.css\ file to define shared design tokens (colors, radii, fonts) for both the main app and standalone documentation exports, ensuring consistent styling without build duplication. Additionally, the data grid now applies specific foreground colors to cells based on their database-aware types (e.g., integer, string, boolean) in both light and dark modes, improving data readability.

apps/desktop/src/styles · high confidence

The update center now centrally manages updates for drivers, JDBC, MCP servers, and plugins, ensuring the UI state (such as toolbar badges and entry points) stays synchronized with actual component changes. This includes logic to persist and execute pending component updates after an app restart, automatically continuing client upgrades, and hiding update entries during active component updates to prevent UI flicker or inconsistency.

apps/desktop/src/lib/updates · high confidence

The SQL editor's autocomplete for ClickHouse has been expanded to support aggregate function combinators (such as Array, Map, ForEach, Distinct, orOrDefault, andOrNull) and table functions (including s3, file, and mysql). This is achieved by adding static definition files for aggregate functions, regular functions, and table functions, along with a registry and a combinator generator that constructs valid function signatures locally without querying a server, ensuring faster and more comprehensive code completion for these specific ClickHouse features.

apps/desktop/src/lib/sql/clickhouse · high confidence

The SQL Library now allows users to define specific folders to scan for SQL files and customize the file name filter used by the external file browser (defaulting to \*.sql). These settings are persisted in local storage, and the system notifies components that cache folder contents whenever the folder paths or filter settings change, ensuring the file list stays up to date.

apps/desktop/src/lib/sqlFile · high confidence

The data grid module has been significantly restructured and expanded with a suite of new libraries. Binary cell handling now supports importing files with a 16 MB size gate, viewing data in a hex/ASCII viewer, and downloading content. The rendering engine introduces a canvas-based renderer for improved performance, along with features like crosshair highlighting, whitespace visualization, and support for boolean checkboxes. Data presentation is enhanced with configurable column formatters (including timezone-aware datetime patterns), cell value generation (UUIDs, snowflake IDs), and cell detail tabs for JSON/XML formatting and value editing. Additional improvements include image preview support for binary columns, external URL detection, and CQL literal parsing for Cassandra collections.

apps/desktop/src/lib/dataGrid · high confidence

The desktop application source code has been moved from the repository root into the apps/desktop/src directory, establishing a new entry point via main.ts and a startup gate (StartupGate.vue) that handles authentication, locale loading, and security migrations before mounting the main App.vue. This relocation introduces a global file content search capability backed by new settings (globalSearchSettings.ts) for configuring search roots and file extensions, and adds a dedicated Solr admin interface (SolrAdmin.vue) for managing Solr cores and server status. The change also includes a test suite for the global search settings logic.

apps/desktop/src · high confidence

The ER diagram canvas now visually indicates relationship cardinalities (one-to-one, one-to-many, many-to-one, many-to-many) on edges, derived from foreign keys and unique indexes. Additionally, table and column comments are rendered directly on the diagram cards, with the layout engine and card sizing updated to accommodate the extra text lines.

apps/desktop/src/lib/diagram · high confidence

The diagram editor now supports multi-schema views via a new schema selection component, allowing users to filter and select specific schemas for the diagram. Users can create and manage draft tables directly within the diagram, including adding columns, indexes, and syncing these changes to the database via a new sync dialog that generates and executes the necessary SQL. The editor also introduces a relationship matching panel where users can review, confirm, or ignore inferred relationships, setting cardinalities for each. Additionally, the diagram toolbar and inspector have been updated to support these new features, including table creation, layer management, and detailed table/relationship inspection.

apps/desktop/src/components/diagram · high confidence

The desktop client now provides deeper integration for Elasticsearch and Apache Solr REST requests. For Elasticsearch, the editor now formats Kibana-style REST requests (METHOD /path {json body}) and renders JSON responses in a dedicated panel. A new visual search profiler parses \\_search?profile=true\ timing data to display query cost and critical paths. Additionally, request risk classification (read, write, dangerous) is now implemented for both Elasticsearch and Solr, ensuring desktop safety guards align with backend logic. Solr support includes a first-class admin panel with views for core status, schema, and analysis.

apps/desktop/src/lib/elasticsearch · high confidence

The desktop application now supports connecting to a significantly wider range of data sources, including new entries for InfluxDB 3.x, Apache Solr, ArgoDB, InterSystems Caché, etcd (with v2 API support), and Salesforce. The generated type definitions also introduce new categories such as 'graph\_ai' and 'registry\_config', and include legacy or specific variants like MongoDB Legacy, H2 2.1 Legacy, and various cloud-native databases (Turso, Cloudflare D1, Databricks).

apps/desktop/src/types/generated · high confidence

The Firebird database agent now supports fetching the full DDL source for stored procedures, including input/output parameters, default values, and nullability constraints. This is achieved via a new SQL query against Firebird's system tables (RDB$PROCEDURES, RDB$PROCEDURE\_PARAMETERS, RDB$FIELDS) and a builder that reconstructs the CREATE OR ALTER PROCEDURE statement. Users can now view and edit procedure definitions directly in the agent interface, with proper handling of mixed-case identifiers and quoted names.

agents/drivers/firebird · high confidence

The H2 database agent now ships with bundled JDBC drivers for H2 versions 1.4, 2.1, and 2.4, allowing it to connect to databases created with any of these storage formats. The agent automatically detects the database file format (PageStore vs. MVStore) and selects the matching driver, or allows users to explicitly specify a driver profile (e.g., h2-v1, h2-v2, h2-v3, or h2-custom). It also correctly detects the remote server version for TCP/SSL connections using H2VERSION(), ensuring metadata queries work accurately regardless of the bundled driver version.

agents/drivers/h2/src/main · high confidence

Introduces the DamengAgent class, providing the core connectivity and metadata handling for Dameng databases. This includes support for standard JDBC connections as well as custom DM6 drivers via configurable paths, lazy initialization of DBMS\_OUTPUT, and specific logic for reading Dameng-specific data types like VARCHAR2 and character length units.

agents/drivers/dameng/src/main · high confidence

This change introduces the Informix database driver, adding the InformixAgent class to handle connections, metadata retrieval, and query execution for Informix databases. It includes logic to build JDBC URLs with support for explicit INFORMIXSERVER settings, automatic fallback to hostnames or default server names, and preservation of manual URL parameters. The agent also implements schema listing by querying systables and sysprocedures owners, database listing from sysmaster, and type mapping for Informix-specific column types. Tests verify URL construction, parameter handling, and metadata queries.

agents/drivers/informix · high confidence

The repository is initialized with the foundational structure required for development and contribution. This includes the Apache 2.0 license, a comprehensive contributing guide (in English and Chinese) detailing the development setup, macOS signing, and testing standards, and a Makefile that standardizes build, test, and database environment commands. Configuration files for Node.js (\.nvmrc\), code formatting (\.oxfmtrc.json\), and Git attributes (\.gitattributes\) are added to ensure consistent environments across platforms and contributors.

(repo-wide) · high confidence

The AI chat now renders specific code blocks as rich, interactive content. Chart-json blocks are displayed as interactive line, bar, and pie charts using ECharts, complete with copy-to-clipboard and PNG download options. HTML blocks are rendered in a fully sandboxed iframe with strict Content Security Policies to prevent script execution, and include a risk warning when copying the raw source. These changes are supported by new parsing, rendering, and security validation logic in the rich content library.

apps/desktop/src/components/ai, apps/desktop/src/lib/ai/richContent · high confidence

The SSH connection flow now supports interactive prompts, allowing users to respond to host key verification, host key changes, and plugin-initiated inputs (such as MFA or custom questions) directly within the desktop application. A new dialog component manages a queue of these prompts, ensuring that first-connect host key challenges are recovered even if the initial WebSocket connection is delayed, and providing a unified interface for both standard SSH security checks and richer plugin-based authentication flows.

apps/desktop/src/components/ssh · high confidence

The driver agent now communicates using Agent Protocol v2, which adds support for multi-session connections, structured error reporting, and expanded capabilities such as paged queries, transactions, DDL, and key-value operations. This change introduces a new driver catalog system that maps database types to specific agent runtimes, allowing multiple profiles (like H2 legacy vs. v2, or etcd v2) to share or use dedicated agents while maintaining a clean driver store. The agent manager now handles offline exports of drivers and JREs into zip archives, manages external process locks on Windows to prevent file conflicts during updates, and implements a recovery policy to automatically replace agent runtimes when they fail or become unresponsive.

crates/dbx-driver-agent · high confidence

Adds a new set of Vue components in the \apps/desktop/src/components/consul\ directory that provide a comprehensive interface for managing Consul infrastructure. This includes \ConsulOverview\ for cluster health and member status, \ConsulAcl\ for managing access control lists, \ConsulMesh\ for service mesh configurations and intentions, \ConsulOperator\ for system-level operations like snapshots and raft management, \ConsulHealth\ for service health checks, \ConsulKeyBrowser\ for key-value store browsing and migration, and \ConsulScope\ for scope management. These components enable users to interact with Consul capabilities directly within the desktop application.

apps/desktop/src/components/consul · high confidence

This change adds a new Db2Agent implementation for the DB2 database driver. It enables users to connect to and query DB2 databases, with specific behavioral improvements for data types: CLOB values are now read as text, and BLOB columns are previewed as hexadecimal strings. The agent also provides metadata capabilities, including listing schemas, tables, and views using DB2-specific system catalogs (SYSCAT), reading view source definitions from SYSCAT.VIEWS, and supporting constrained metadata queries with pagination and filtering.

agents/drivers/db2 · high confidence

Users can now browse HBase tables directly in the desktop app via a new HBaseBrowser component that leverages the HBase REST API. This component allows users to scan rows by prefix or exact key, view table schemas, and perform write operations (subject to connection read-only status). The UI state for each tab—including lookup mode, row key input, row limit, and dialog states—is now persisted across sessions, and query execution time is displayed in adaptive units.

apps/desktop/src/components/hbase · high confidence

Users can now connect to an MQTT broker and manage subscriptions via a new Admin Console. The console displays a hierarchical topic tree, allows subscribing/unsubscribing to topics with configurable QoS and NoLocal options, and shows incoming messages in a scrollable list. Key features include pausing and resuming the message stream to prevent auto-scrolling, searching message payloads locally, and collapsing individual message payloads for better readability. A separate Publish dialog enables sending messages with support for various payload encodings (plaintext, JSON, base64, hex, CBOR, msgpack) and adjustable input height. Topic subscriptions and UI states (such as collapsed payloads and search filters) are persisted across sessions.

apps/desktop/src/components/mqtt · high confidence

Added the \MongoAgent\ implementation in \agents/drivers/mongodb\, providing a full-featured MongoDB driver that supports both legacy and modern agent protocols. The driver preserves data fidelity by handling null fields, date-shaped strings, int64/long IDs, and BSON types during transfers and exports. It implements a wide range of MongoDB operations including \find\, \aggregate\, \bulkWrite\, \replaceOne\, \insertMany\, \updateOne/Many\, and shell commands like \drop\, \renameCollection\, \createUser\, and \runCommand\. New features include collection cloning, generic \runCommand\ execution, and streaming exports via find cursors. The implementation also handles authentication nuances, such as falling back to authorized databases on list denial and fixing default database authentication issues, while ensuring legacy agent compatibility through specific index, filter, and upsert support.

agents/drivers/mongodb · high confidence

Added support for the Pi Coding Agent as a new AI provider in the Desktop client. This change introduces a new \pi-agent-cli\ provider type and a dedicated Node.js bridge script (\pi-mcp-bridge.mjs\) that spawns the Pi CLI process, manages its lifecycle, and exposes its tools to the DBX agent loop via the Model Context Protocol (MCP). The Rust implementation in \dbx-ai-provider\ handles the provider registration, event streaming, and tool execution integration, allowing users to interact with the Pi agent for code assistance without requiring an external API key.

crates/dbx-core · high confidence

The QuickOpen dialog component has been implemented to support a new global file content search mode, allowing users to search across file contents with configurable search roots and file extensions. The dialog also integrates with the plugin system, enabling users to open standalone plugin workbenches and execute plugin commands directly from the quick-open interface. Additionally, the component handles keyboard navigation and displays highlighted search matches within file content results.

apps/desktop/src/components/quick-open · high confidence

Added a new \dbx-sqlite-worker\ crate that provides a standalone process for handling SQLite database interactions via a JSON-over-stdio protocol. This worker supports opening databases, executing queries (with row and size limits), performing backups and restores, and basic lifecycle management (ping/close). It exposes a structured request/response API (\WorkerRequest\/\WorkerResponse\) allowing other components to offload SQLite operations, including remote batch saves, to a dedicated worker process.

crates/dbx-sqlite-worker · high confidence

The DBX MCP server now supports a Streamable HTTP transport mode alongside the existing stdio mode, enabling embedding in web backends or standalone HTTP servers. This change adds a new \--http\ transport option, configurable via environment variables (\DBX\_MCP\_TRANSPORT\, \DBX\_MCP\_HTTP\_HOST\, \DBX\_MCP\_HTTP\_PORT\, \DBX\_MCP\_HTTP\_PATH\) and command-line arguments. The HTTP endpoint includes built-in authentication using a bearer token (configured via \DBX\_MCP\_HTTP\_TOKEN\ or \DBX\_MCP\_HTTP\_TOKEN\_FILE\) and strict origin/host validation to prevent unauthorized access. It also implements session management with configurable idle timeouts and a maximum session limit, ensuring resource control. The implementation includes a health check endpoint (\/healthz\, \/readyz\) and supports graceful shutdown. This allows MCP clients to connect over HTTP with proper security controls, suitable for remote or web-integrated scenarios.

crates/dbx-mcp · high confidence

Added a new VectorBrowser.vue component that provides a unified interface for browsing, upserting, deleting, and searching data in vector databases. The component supports multiple backends including Milvus, Weaviate, ChromaDB, and Qdrant, handling specific requirements such as Milvus schema derivation and Weaviate search vector dimensions. It also persists inactive tab UI state to maintain user context across sessions.

apps/desktop/src/components/vector · high confidence

Added new library modules in the desktop app to handle ZooKeeper connection string normalization, endpoint parsing, and authentication scheme configuration. Users can now connect to ZooKeeper clusters using standardized connect strings that support multiple hosts and various URI formats, with automatic fallback to the default port (2181). The system also supports configuring authentication schemes (digest or sasl\_digest) via connection parameters, enabling secure cluster authentication setup.

apps/desktop/src/lib/zookeeper · high confidence

The desktop application now supports scheduled database backups that run in a background worker process, ensuring backups continue even if the main UI is closed. Additionally, a new agent driver management system allows users to install, upgrade, and manage database-specific driver agents (including offline imports and JRE configuration) directly from the application.

src-tauri · high confidence

Added a new DatabaseSearchDialog component that allows users to search across all tables in a database. The implementation uses a batched scanning approach (importing databaseSearchBatchRange and databaseSearchNextBatchSize) to iterate through tables, providing progress tracking, error handling per table, and result previews. It filters out system schemas and supports pre-filled connection, database, and schema contexts.

apps/desktop/src/components/search · high confidence

Users can now export selected code as a self-contained PNG image that mimics a native code editor window, complete with syntax highlighting, line numbers, and optional macOS-style traffic lights. The implementation ensures high-fidelity output by preserving line structure and layout even when the syntax highlighter fails or encounters legacy WebKit regex limitations, falling back to safe, line-preserving text. It also includes specific semantic highlighting for SQL table names and proper escaping of snapshot titles to prevent XSS.

apps/desktop/src/lib/codeSnapshot · high confidence

The desktop application now uses dedicated Vue composables to manage core runtime behaviors. \useAppUpdater\ centralizes update logic, including version parsing, download source resolution (CNB/official), and background download handling. \useComponentUpdates\ orchestrates updates for drivers, JDBC plugins, MCP servers, and marketplace plugins, exposing availability and blocking reasons. \useAiModelCatalog\ provides a cached, fingerprinted catalog of AI models and effort capabilities to avoid redundant API calls. \useBackgroundImage\ handles loading and applying custom wallpapers with proper color palette synchronization. \useCellDetailEditor\ replaces the previous cell editor implementation with a CodeMirror-based editor supporting JSON mode, font zooming, and search. \useCloseActionPrompt\ manages the new configurable quit-on-close behavior and system close request handling.

apps/desktop/src/composables · high confidence

The SQL formatter now uses a new internal layout engine that provides a distinct formatting style: \CREATE TABLE\ statements feature aligned column definitions (name, type, and modifiers line up in columns), and general queries use column-relative alignment where clause continuations align under the first item rather than using fixed indent levels. This engine also fixes a bug where line comments (\--\) would swallow subsequent tokens by ensuring the output buffer starts a new line after a comment, and it preserves parenthesized branches in \UNION ALL\ operations that were previously lost.

apps/desktop/src/lib/sql/layout · high confidence

Adds the DataGenerateDialog component and GeneratorSelect UI to enable bulk data generation with streaming progress, configurable timeouts, and JSON literal support. The dialog now persists generation configurations across sessions and honors explicit unique value settings, while deduplicating unique-constraint columns by default to prevent constraint violations.

apps/desktop/src/components/generate · high confidence

The desktop application now supports creating new databases and editing their properties. This change adds a dedicated library layer in \apps/desktop/src/lib/database\ that handles the generation of dialect-specific SQL for database creation (including charset, collation, and locale options for MySQL-compatible engines and GBase 8s), manages connection error hints, and defines the authorization plans for user and role administration. It also introduces support for Dameng-specific features such as job administration, user/role management, and SSL configuration, alongside generic utilities for data transfer selection and database capability detection.

apps/desktop/src/lib/database · high confidence

This change adds the core library logic for a database-aware version control workspace in the Dolt integration. It introduces \doltVersionControl.ts\ to handle Dolt-specific operations such as generating SQL for commits, branches, merges, and diffs, as well as classifying table and row changes. It also adds \doltCellDiff.ts\ to provide granular, cell-level diffing capabilities, including automatic detection of JSON and XML formats, formatted display values, and text diffing for comparing original and edited values within the grid.

apps/desktop/src/lib/dolt · high confidence

A new version control workspace has been added for Dolt databases, providing a dedicated UI for comparing revisions and managing branches. This includes a revision selector for filtering and navigating branches and tags, a virtualized diff table for viewing row-level changes with adjustable column widths, and a pagination component for large result sets. Users can inspect individual cell differences in a side-by-side dialog that supports auto-detection and manual formatting (JSON, XML, raw) of cell values, along with clipboard copy functionality.

apps/desktop/src/components/dolt · high confidence

The \plugins/sdk/cli\ directory now contains the \dbx-plugin\ CLI, a Rust-based tool that enables developers to create, run, and package DBX plugins. The CLI provides a \create\ command with four project templates—frontend-only, Svelte + Vite, Rust sidecar, and Go sidecar—each generating a standardized project structure including \manifest.json\, \dbx-plugin.toml\, and CI release workflows. It includes a \dev\ command that launches a browser-based development host (requiring Node.js 22+) to run plugin workbenches and manage native sidecars without the full DBX desktop application. Additionally, the \package\ command stages project assets and produces signed \.dbxp\ candidates for distribution, while the included templates demonstrate the new Host Bridge API for sandboxed UI and backend communication.

plugins/sdk · high confidence

The editor area now includes a new LoginPage component that handles user authentication and initial setup, featuring password validation and backend error translation. Additionally, the AiAssistant component has been added to provide a comprehensive AI interface within the editor, supporting features such as agent tool calling, conversation management, and attachment handling. Supporting UI components AiAttachmentCard and AiToolApprovalCard have also been introduced to manage file attachments and tool execution approvals within the AI assistant workflow.

apps/desktop/src/components/editor · high confidence

A new experimental native Oracle agent written in Go has been added to the DBX drivers, replacing the previous Java-based implementation. This agent uses the \github.com/sijms/go-ora/v2\ library and supports TNS connections by parsing JDBC-style URLs (e.g., \jdbc:oracle:thin:@alias\) and resolving aliases from \tnsnames.ora\ files. It includes a multi-session protocol for managing multiple database connections, handles various Oracle data types (including LOBs, XMLTYPE, and SDO\_GEOMETRY), and provides metadata capabilities such as schema browsing, DDL generation, and query execution. The agent is designed to be dropped into the DBX driver directory and is preferred over the legacy Java agent.

agents/drivers/oracle-go · high confidence

This change adds a new native Go-based agent for XuguDB, replacing or supplementing the previous Java/JDBC approach. The agent implements the DBX protocol (v1/v2) to provide full metadata browsing—including tables, views, indexes, columns, constraints, package members, and scheduler jobs—and supports query execution, DML transactions, and reconstructed DDL generation. It includes specific handling for Xugu-specific features such as index partitions (LOCAL/GLOBAL), identity columns, spatial SRIDs, and structured error reporting. To ensure reliability, the location also adds a suite of live integration tests covering connection reuse, data type catalog validation, index partition DDL reconstruction, and structured error round-trips.

agents/drivers/xugu · high confidence

This change replaces the legacy Java-based Kingbase agent with a new native Go implementation, adding the \gitea.com/kingbase/gokb\ driver dependency. The new agent provides full metadata capabilities, including support for V7 and V8 catalogs, MySQL and SQL Server compatibility modes, and detailed handling of table constraints, indexes, triggers, partitioning, and user-defined types. It also includes a new benchmarking tool for performance comparison and extensive integration tests to validate connection handling, query execution, and metadata retrieval.

agents/drivers/kingbase-go · high confidence

The desktop application now uses a new DataGrid component structure located in apps/desktop/src/components/grid. This includes a main DataGrid.vue entry point and a suite of supporting UI components such as DataGridAutoRefreshClock, DataGridBulkEditDialog, DataGridBusyOverlay, DataGridCellDetailDialog, and DataGridCellDetailHeader. These components provide the visual and interactive foundation for the data grid, including auto-refresh indicators, bulk editing capabilities, busy state overlays, and detailed cell/row/column information panels.

apps/desktop/src/components/grid · high confidence

Adds a new, optional sidecar plugin that enables DBX to connect to external databases via standard JDBC drivers. The plugin includes a Gradle-based build system, launcher scripts for Unix and Windows, and a Maven resolver utility for downloading driver JARs. It supports JDBCX profiles for driver discovery, handles driver-specific quirks (such as MySQL cursor fetching and Oracle metadata), and allows users to install and manage database drivers in a local store to connect to a wide range of databases without bundling them with the main application.

plugins/jdbc · high confidence

The \@dbx-app/plugin-cli\ package now provides a precompiled \dbx-plugin\ command-line tool that allows users to create, package, and develop DBX plugins without needing a full DBX source checkout. The CLI automatically selects the correct precompiled binary for the user's platform (macOS, Linux, or Windows) and bundles the matching Rust and Go SDK sources. It introduces a \dev\ subcommand that runs a bundled browser-based development runtime (requiring Node.js 22+), supporting frontend-only workbenches and Rust/Go backends, while other commands retain existing Node.js requirements. Development credentials are stored locally in \.dbx-dev/\.

packages/plugin-cli · high confidence

Added the go-gssapi library to the agent's common codebase, providing a pure-Go implementation of the GSS-API specification (RFC 2743) with Kerberos V5 support (RFC 4121). This new package enables the agent to perform mutual authentication, message integrity, and confidentiality without relying on system-level GSS-API bindings. The implementation includes context negotiation loops, token marshalling/unmarshalling, and platform-specific default path handling for Kerberos configuration and credentials.

agents/go-common/go-gssapi · high confidence

The transfer dialog now supports saving and reusing transfer configurations. A new task tree component allows users to create, rename, and organize transfer tasks into folders, with search filtering across task names and database paths. The main dialog can load a saved task's configuration (source/target connections, selected objects, and strategy) for editing or re-execution, and tracks active transfer progress in a dedicated progress dialog.

apps/desktop/src/components/transfer · high confidence

This change adds the core TypeScript interfaces and logic required for scheduled, background database backups. It defines the data models for backup schedules (including frequency, retention, and time zones) and run history, along with utilities for table filtering (include/exclude patterns), compression settings, and file naming. It also introduces a connection queue to manage concurrent backup operations and storage keys for persisting schedule and run data, laying the groundwork for the scheduled backup feature.

apps/desktop/src/lib/backup · high confidence

The desktop application now uses a centralized \api.ts\ module that forwards all backend operations through a lazy-resolved transport, allowing the same frontend code to run in both the native Tauri desktop environment and a web browser via HTTP. This change introduces a new \configCrypto.ts\ module that encrypts local connection credentials and configuration using AES-GCM with PBKDF2 key derivation, replacing the previous plaintext storage. Additionally, \browserAppStateStorage.ts\ provides IndexedDB-backed persistence for browser mode, with a structured-clone-safe JSON serialization to handle Vue reactive proxies and a localStorage fallback to prevent workspace freezes.

apps/desktop/src/lib/backend · high confidence

This change adds a new \dbx-types\ crate that centralizes core data models and runtime configuration. It introduces a build-time code generator (\build.rs\) that reads YAML descriptors from \plugins/connection-types\ to automatically generate a \DatabaseType\ enum and a \database\_manifest.json\ file, enabling the application to dynamically discover supported database drivers and their properties (such as default ports and runtime modes). The crate also adds \MongoGridFsFileInfo\ and \MongoGridFsBucketInfo\ structs for MongoDB GridFS support, a \TableNameFilter\ with SQL-like pattern matching for metadata filtering, and \json.rs\ utilities to safely serialize large integers as strings to prevent precision loss in JavaScript environments.

crates/dbx-types · high confidence

The IoTDB database agent has been rewritten in Go, replacing the previous Java/JDBC-based implementation. This change significantly reduces startup latency (by \~95%), memory usage (RSS reduced by \~89%), and binary size. The new native agent supports both Tree and Table SQL dialects, handles timezone data internally, and maintains compatibility with existing connection parameters including compression and TLS settings. A benchmark suite comparing the old JDBC driver against the new Go implementation is included for reference.

agents/drivers/iotdb · high confidence

The desktop application now includes dedicated libraries for managing Model Context Protocol (MCP) integration. New configuration templates in \mcpConfigTemplates.ts\ generate settings for various hosts including Trae, Qoder, VS Code, Cherry Studio, Codex, DeepSeek Harness, OpenCode, Pi, and WorkBuddy, with support for native binary execution on Windows. A new policy system in \mcpPolicySelection.ts\ defines execution modes (read-only, safe-write, high-risk-write) and granular tool permissions (e.g., batch execution, plugin tools, Salesforce operations). Additionally, \mcpUpdateStatus.ts\ introduces logic to track and display update availability for the MCP server.

apps/desktop/src/lib/mcp · high confidence

The DBX MCP server has been rewritten in Rust and is now distributed as a small Node.js launcher that spawns a platform-specific native binary (e.g., dbx-mcp.exe on Windows, dbx-mcp on Linux/macOS). This change removes the need for local Rust/Cargo builds and eliminates the better-sqlite3 Node native-addon dependency. The launcher handles platform detection, optional native package resolution, and process lifecycle management, including hiding the Windows console window. Tests verify the launcher's behavior, including symlinked invocation and platform support.

packages/mcp-server · high confidence

The resource lifecycle diagnostics now include metadata cache metrics (entry count and byte size) alongside existing query cache and cancellation statistics. This allows users to monitor metadata runtime cache usage when viewing the overall resource lifecycle snapshot in the desktop app.

apps/desktop/src/lib/diagnostics · high confidence

The mongo-shell package now includes a new TypeScript implementation for parsing and preprocessing MongoDB shell commands. This adds support for parsing \db.collection.aggregate()\ calls with optional options, handling shell-specific syntax such as regex literals, comments, trailing commas, and bracket accessors, and normalizing shell constructors (like ObjectId) into Extended JSON. It also allows dropping no-op cursor methods like \.toArray()\ and \.pretty()\ after queries, enabling more idiomatic MongoDB shell usage within the application.

packages/mongo-shell · high confidence

This update introduces several capabilities for managing Nacos configurations within the desktop app. It adds syntax validation for config editors, including YAML diagnostics with error location, JSON/XML/HTML/TOML/Properties support, and content replacement with persistent rollback. It also adds service and instance management improvements, such as health status display and access control/namespace administration. Additionally, it includes r-nacos compatibility, global content replacement, and dashboard metrics.

apps/desktop/src/lib/nacos · high confidence

The desktop app now includes a dedicated Nacos management console. This update adds an access control interface for managing users and roles (including r-nacos compatibility), and a configuration management workspace supporting batch operations (export, import, copy with conflict handling), config history viewing with rollback, and side-by-side or inline diff comparisons for configuration changes.

apps/desktop/src/components/nacos · high confidence

A new Vue directive, vNamingStyleSupport, allows users to cycle through naming conventions (camelCase, PascalCase, snake\_case, SCREAMING\_SNAKE\_CASE, kebab-case) in text inputs and text areas. The feature is triggered by a configurable keyboard shortcut (defaulting to Shift+Alt+C) and respects user settings, ensuring that macOS composed keys are handled correctly and that the conversion only applies to identifier-like content.

apps/desktop/src/directives · high confidence

This location introduces a new native Go-based Cassandra agent that replaces the previous JVM-based implementation, offering significantly faster startup times and lower memory usage as demonstrated by benchmark results. The agent implements the DBX multi-session JSON-RPC protocol using the Apache \cassandra-gocql-driver\ and maintains compatibility with existing JDBC-style connection strings and URL parameters. It supports native protocol versions v3-v5, TLS with JKS/PKCS\#12 stores, Kerberos/GSSAPI authentication, and DataStax Astra secure connect bundles. The implementation includes configuration file support for Java Driver 4 HOCON settings, cursor-based pagination for table data and exports, and comprehensive integration tests covering metadata retrieval, query execution, and various authentication modes.

agents/drivers/cassandra-go · high confidence

The Hive database agent has been rewritten in Go, removing the dependency on the Java Hive JDBC driver and the JRE. This native agent implements the same JSON-RPC protocol and supports the same connection features (including ZooKeeper service discovery, Kerberos authentication, and HTTP transport), ensuring functional parity with the previous Java-based implementation while reducing runtime overhead and eliminating the need for a Java installation.

agents/drivers/hive-go · high confidence

The RocketMQ driver has been rewritten from a Java agent to a native Go implementation, introducing a new set of source files (acl.go, cluster.go, connection.go, consumers.go, helpers.go, main.go, messages.go, etc.) that expose the same management capabilities—such as cluster description, consumer group management, ACL handling, and message peeking/viewing—via a JSON-RPC protocol over stdin/stdout. The new agent uses the github.com/amigoer/rocketmq-admin-go library for broker communication, supports connection configuration via name servers, access keys, timeouts, TLS skip verify, and SOCKS proxies, and includes comprehensive unit and integration tests to validate the new Go-based behavior.

agents/drivers/rocketmq · high confidence

The Vastbase database agent has been rewritten in pure Go, replacing the previous Java/JDBC implementation with the openGauss-connector-go-pq driver (v1.0.8). This change eliminates the JVM dependency, resulting in a standalone native binary that improves startup time and reduces memory overhead. The new agent supports Vastbase's compatibility modes (Oracle, MySQL, PostgreSQL, SQL Server) and includes a benchmark suite to compare performance against the legacy JDBC agents.

agents/drivers/vastbase-go · high confidence

Users can now export AI assistant interactions and analysis results as standalone Markdown or HTML files. The new \aiConversationExport\ module generates a transcript of user and assistant messages, preserving code fences verbatim in Markdown and escaping raw HTML in HTML exports to prevent injection. HTML reports include a strict Content Security Policy (CSP) to block external resources and render fenced code blocks as escaped text. Additionally, an \aiAnalysisExport\ module allows exporting single AI analysis results as Markdown. These features are supported by new test coverage for conversation formatting, null handling in CSV/TSV exports, PNG scale clamping for large diagrams, and schema filtering for Xugu databases.

apps/desktop/src/lib/export · high confidence

Added dedicated agent drivers for Apache Ignite 2.x (via the thin JDBC driver) and Ignite 3 (via the standard JDBC driver). These agents expose schema, table, and column metadata to the DBX object browser. The Ignite 2 agent includes full index metadata support, correctly aggregating ordinal columns and identifying primary keys, while the Ignite 3 agent provides basic schema and table listing but currently returns empty lists for indexes, foreign keys, and triggers.

agents · high confidence

The plugins/examples area now includes a complete 'DBX Hello Workbench' plugin that demonstrates the full manifest v1 plugin lifecycle. It features a native Rust sidecar, a sandboxed workbench UI, a connection provider with secret field bindings, and a virtual filesystem provider rendered by the host. The plugin integrates with the built-in AI assistant via MCP tools, including a read-only greeting tool and a state-changing tool that requires user consent. The example also provides scripts for building unsigned development packages, custom repository signing, and end-to-end smoke tests, along with a sample marketplace catalog to illustrate the repository-signed artifact shape.

plugins/examples · high confidence

The product now includes dedicated drivers for Elasticsearch and MongoDB, enabling users to connect to and query these database systems. The Elasticsearch driver supports both direct connections and Kibana proxy modes, with configurable TLS, timeouts, and index grouping. The MongoDB driver adds support for OIDC browser-based authentication, direct connection mode for single-host setups, and a comprehensive shell interface for executing commands like find, update, and aggregate.

crates/dbx-driver-elasticsearch, crates/dbx-driver-mongodb · high confidence

The agents module now includes dedicated JDBC drivers for five additional database platforms: Databricks, Exasol, Kylin, Teradata, and Vertica. Each driver is implemented as a standalone agent (e.g., DatabricksAgent, ExasolAgent) that registers its specific JDBC profile and exposes a MultiSessionJsonRpcServer for connection management. Kylin includes custom metadata handling for catalogs and tables, while the others rely on standard JDBC profiles. Tests are provided for Databricks and Kylin to validate URL construction and basic execution behavior.

(repo-wide) · high confidence

Added a new Meilisearch workspace area that provides comprehensive management capabilities for Meilisearch connections. Users can now create and manage indexes, view and edit index settings, browse and search documents with multiple view modes (JSON, table, grid), and manage API keys and tasks. The workspace includes an overview page showing system health and storage stats, a keys management page for creating and editing API keys with granular permissions, and a tasks page for monitoring and filtering index operations. Document management features support search with highlighting, editing, deletion, and JSON export/import functionality.

apps/desktop/src/components/meilisearch · high confidence

This change introduces a new set of TypeScript modules and unit tests for the MongoDB integration in the desktop app. It adds logic to detect MongoDB OIDC authentication in connection strings, defines driver capability profiles (including support for legacy driver spellings and read-only restrictions), and implements a context-aware completion engine for the MongoDB shell editor (supporting fields, operators, and collection methods). It also adds utilities for formatting and editing MongoDB document values in the grid (handling Extended JSON dates and types) and manages index metadata in the sidebar. The entry is grounded in the added test files (\mongoCapabilities.spec.ts\, \mongoConnectionOptions.spec.ts\, \mongoDocumentQueryCompletion.spec.ts\, \mongoDocumentValues.spec.ts\, \mongoIndexMetadata.spec.ts\, \mongoQueryResultEditing.spec.ts\, \mongoSiblingDatabaseCompletion.spec.ts\) and the corresponding implementation files (\mongoCapabilities.ts\, \mongoCompletion.ts\, \mongoCompletionTables.ts\, \mongoConnectionOptions.ts\, \mongoDocumentValues.ts\).

apps/desktop/src/lib/mongo · high confidence

The \dbx-sql-core\ crate has been introduced to centralize SQL logic previously scattered across the workspace. It provides capabilities for generating safe DML preview queries (converting UPDATE/INSERT/DELETE to read-only SELECTs), normalizing MySQL DDL exports (stripping AUTO\_INCREMENT and updating ROW\_FORMAT), and constructing MySQL event definitions. It also handles executable SQL generation for routine renames and views across multiple dialects (PostgreSQL, Oracle, MySQL, SQL Server, etc.), builds EXPLAIN plans with dialect-specific strategies, and performs SQL reference analysis and diagnostics (including sensitive data redaction).

crates/dbx-sql-core · high confidence

The \crates/dbx-sql-dialect\ crate introduces a new SQL dialect engine that manages database-specific capabilities and SQL generation. Dialect definitions are now driven by YAML descriptors loaded at startup, with a build script embedding core dialects and watching for changes to prevent stale type catalogs. The engine includes a \DmlCleanRuleRegistry\ and \BindingEngine\ to automatically bind pre-transform SQL for lossy type mappings during data movement, and provides detailed DDL profiles (covering quoting, auto-increment, index syntax, and triggers) to ensure generated SQL matches the target database's grammar.

crates/dbx-sql-dialect · high confidence

The \crates/dbx-sql-schema\ crate has been introduced to centralize SQL schema management, providing structured types and logic for database administration (including creating, dropping, and renaming databases, schemas, and tables) and comprehensive schema diffing across multiple database engines (PostgreSQL, MySQL, SQL Server, DuckDB, ClickHouse, and others). It includes an AST-based SQL sandbox for filtering and validating SQL statements, a Git diff scanner for extracting SQL changes from repositories, and an input resolver that supports loading DDL from files, live database connections, or Git diffs. The crate also handles table structure changes, including column alterations, index management, foreign keys, and engine-specific features like SQL Server dependency handling and MySQL charset stripping.

crates/dbx-sql-schema · high confidence

The SQL editor now uses a dedicated semantic analysis layer to power intelligent features. This new system provides accurate table and column completion (including support for SELECT \* expansion and CTE navigation), precise syntax and reference diagnostics (with specific handling for SQL Server routine batches and Oracle-style blocks), and visual alias highlighting. It also introduces dialect-specific adapters to correctly handle identifier quoting, normalization, and projection alias visibility across databases like MySQL, PostgreSQL, SQL Server, Oracle, and ClickHouse.

apps/desktop/src/lib/sql/semantic · high confidence

Added a suite of new scripts under \scripts/bench/\ to measure SQL editor typing performance, startup bundle static dependencies, and database-specific operations (MongoDB count, Redis key search). Included \scripts/benchmark-cli.mjs\ to compare the new Rust CLI against the legacy version, \scripts/ai-html-runtime-canary.mjs\ to validate safe HTML preview security boundaries, \scripts/build-knowledge-base.mjs\ to generate documentation-based knowledge entries, and \scripts/check-mq-integration.mjs\ to verify message queue feature wiring across the frontend, backend, and Tauri layers.

scripts · high confidence

The desktop app now includes dedicated Vue components for visualizing data: MetricLineChart renders time-series line charts for live metrics, while QueryChart allows users to interactively select X and Y axes and switch between bar, line, and pie chart types for query results. Both components support dark mode theming and are built on ECharts.

apps/desktop/src/components/chart · high confidence

Added a suite of reusable Vue components to the common library to support new data viewing and interaction features. This includes Elasticsearch-specific panels for rendering JSON responses with in-content search and visualizing query performance profiles, alongside a virtualized JSON tree for handling large datasets. General-purpose components introduced are a side-by-side text diff viewer with synchronized scrolling, a draggable floating search bar, a virtual scroll area with custom scrollbars, and UI elements for query error actions, loading states, metric cards, and production environment warnings.

apps/desktop/src/components/common · high confidence

This change introduces a suite of new Vue components in the desktop app's configuration area to enhance driver management and configuration portability. Users can now export and import specific connections and agent drivers for offline use via dedicated selection dialogs (ConfigConnectionSelectDialog, AgentOfflineExportDialog) with passphrase protection (ConfigPassphraseDialog). The DriverStoreDialog and its sub-components (DriverStoreAgentRow, DriverInstallProgressCircle) provide a unified interface for managing agent drivers, including installation, updates, queueing, and custom store path configuration. Additional panels support configuration drift detection (ConfigDriftPanel), hot-reload notifications (ConfigHotReloadIndicator), and business tag management (TagManagementPanel).

apps/desktop/src/components/config · high confidence

The desktop app now prompts users to confirm whether to quit when closing the application while AI agent sessions are still running. A new \AiRunsClosePromptDialog\ component displays the count of active runs and offers options to cancel the quit or proceed with quitting, ensuring users are aware of pending background AI tasks before the application closes.

apps/desktop/src/components/layout · high confidence

The connection dialog now supports creating and editing Cloudflare D1 and Google Cloud Spanner connections, with Spanner offering both structured and raw resource path editing modes. Users can also manage reusable SSH, proxy, and HTTP tunnel profiles via a dedicated manager, allowing them to be selected and tested independently of individual database connections.

apps/desktop/src/components/connection · high confidence

The desktop app now includes a suite of new Vue components in the diff area to support data comparison and schema synchronization workflows. DataCompareDialog provides the main interface for comparing and syncing data, featuring per-table key column configuration via CompareKeyColumnsSelect, batch execution, and manual transaction support. Schema diff capabilities are enhanced with FieldMappingDialog and FieldMappingPanel for managing type mappings between different database dialects, while ConflictMatrix and RebasePanel handle object-level conflicts and baseline drift. Operational safety and visibility are improved through ImpactReportPanel for risk assessment and OscStatusPanel for tracking online schema change progress.

apps/desktop/src/components/diff · high confidence

The \crates/dbx-sql-data\ crate now includes a comprehensive data grid extraction system that allows users to export selected grid data into multiple formats including CSV, TSV, JSON, SQL (INSERT/UPDATE/SELECT), Markdown, HTML, XML, and raw text. This subsystem introduces a versioned contract (\DATA\_GRID\_EXTRACTOR\_CONTRACT\_VERSION\) with configurable options for delimiters, quoting policies, and SQL generation modes (such as skipping computed/generated columns or excluding primary keys). It also adds IoTDB-specific SQL statement builders for table model saves and rollbacks, ensuring proper handling of IoTDB's time and TAG identifiers. The implementation includes strict budget limits on input/output size and row/column counts to prevent resource exhaustion during extraction.

crates/dbx-sql-data · high confidence

Added new admin UI components to manage Dameng users, roles, and scheduled jobs, and to administer database and table-level user privileges across MySQL, PostgreSQL, and StarRocks via a shared authorization scope editor. Also introduced server metrics dashboards for MySQL and PostgreSQL that display real-time performance statistics such as QPS/TPS, connection counts, and cache hit ratios with configurable auto-refresh intervals.

apps/desktop/src/components/admin · high confidence

The new \crates/dbx-driver-support\ crate provides shared utilities for database drivers, including an SSH configuration parser that follows \Include\ directives in \\~/.ssh/config\ and resolves \ProxyJump\ chains, and an Elasticsearch SQL translator that converts \SELECT \*\ statements into Elasticsearch \\_search\ DSL bodies. It also introduces structured connection pool error reporting, TLS certificate handling for custom CAs and client identities, and a file path validator for connection credentials.

crates/dbx-driver-support · high confidence

The \dbx-drivers\ crate now includes dedicated drivers for ClickHouse, Cloudflare D1, and Cloudberry. The ClickHouse driver enables HTTP-based connectivity with custom CA certificate support and extra query parameters. The Cloudflare D1 driver provides a managed SQLite interface with strict SQL validation, statement size limits, and support for FTS5 virtual tables. The Cloudberry driver extends PostgreSQL capabilities to handle external tables, distribution policies, and specific table modifiers.

crates/dbx-drivers · high confidence

A new Go-based agent for Transwarp ArgoDB has been added to the drivers directory, forked from the existing Hive Go agent but configured to unconditionally support stored procedures (routines) and report its identity as 'ArgoDB (Transwarp)'. This agent handles PL/SQL splitting to ensure stored-procedure source code and \CREATE OR REPLACE PROCEDURE\ statements are executed as single statements, providing readable diagnostics on execution errors. The change includes a comprehensive benchmarking suite (\bench/\) with functional parity probes and performance comparison tools against the JDBC agent, as well as a Kerberos test fixture for isolated validation.

agents/drivers/argo-go · high confidence

This change introduces a set of new TypeScript modules in the desktop app's core library to manage application state and configuration. It adds support for configurable global background wallpapers (with opacity, blur, and display modes), custom UI color palettes and themes, and font family settings. It also implements persistence logic for open tabs and detached window handoffs, and introduces background update installation flows with task guards to prevent interruptions during active queries.

apps/desktop/src/lib/app · high confidence

The desktop app now uses dedicated Vue components to render connection and AI provider logos. \AiProviderLogo.vue\ displays logos for AI providers (including Claude, Anthropic, Ollama, OpenAI, OpenCode, Cursor, and Grok) with theme-aware inversion and text fallbacks. \DatabaseIcon.vue\ maps database types (such as OceanBase Oracle mode, Phoenix, Impala, Kyuubi, Inceptor, Meilisearch, and many others) to specific asset files, applying CSS adjustments for dark mode and specific logos. \ConnectionIcon.vue\ acts as a dispatcher, showing plugin icons for plugin-based connections and database icons for native ones. These changes ensure consistent, theme-aware iconography across the desktop interface.

apps/desktop/src/components/icons · high confidence

This change introduces a new DocumentBrowser component and supporting UI elements for the desktop application. The DocumentBrowser provides a unified interface for viewing, editing, and managing documents across multiple database types, including MongoDB, Elasticsearch, Solr, Meilisearch, and DynamoDB. It features a data grid with configurable column layouts, drag-and-drop reordering, and type-aware cell coloring. The update also adds MongoDB-specific tools: a GridFS bucket and file browser for managing large files, a database dump/restore dialog for backups, and an import dialog for CSV/JSON data with type inference and preview. Additionally, a new JsonEditNode component enables structured, field-by-field editing of JSON documents, and a DocumentQueryCompletionMenu provides context-aware autocompletion for query filters.

apps/desktop/src/components/document · high confidence

A new Go-based agent driver (\etcd2\) has been added to support the etcd v2 HTTP/JSON API, enabling connections to etcd 2.0–2.3 servers and etcd 3.x instances started with the \--enable-v2\ flag. This driver implements the standard DBX agent protocol and provides capabilities for key-value operations (including TTL, CAS, and listing), authentication management, and long-poll watching. It deliberately excludes v3-only features such as leases, history, and compaction, and includes specific handling for v2 limitations like non-atomic renames and reduced status metrics.

agents/drivers/etcd2-go, agents/go-common/go-semver · high confidence

The etcd connection view now includes a comprehensive workbench featuring an Access Control panel for managing users and roles, an Admin Console for maintenance operations (compaction, defragmentation), lease management, and key watching, and a Dashboard displaying cluster health and detailed performance metrics. These components replace the previous basic key browsing interface with a full-featured management experience for etcd clusters.

apps/desktop/src/components/etcd · high confidence

The export area now includes dedicated Vue components for the database export dialog, export progress dialog, export progress popover, SQL insert mode selection, and XLSX header configuration. The progress popover and dialog now support copying detailed failure information for data transfer and SQL file tasks, and the progress dialog displays the real saved file name instead of a synthetic label.

apps/desktop/src/components/export · high confidence

The desktop app now uses a set of custom, lightweight Vue components to replace heavier third-party UI libraries, improving performance and stability. This includes CustomContextMenu for faster context menus with submenu support, LightDropdown and LightDropdownMenu for responsive dropdowns, LightTooltip for instant and non-lingering tooltips, and ErrorBanner with built-in copy-to-clipboard functionality. Additional components like ColorSpectrumPicker, PasswordInput, and PasswordTextarea enhance the settings and connection interfaces.

apps/desktop/src/components/ui · high confidence

Added a suite of new Vue components in the data generation parameters directory to support localized synthetic data creation. These components include AddressParams, BarcodeParams, CityParams, ColorParams, CompanyNameParams, CreditCardDateParams, CreditCardNumberParams, CreditCardTypeParams, DateParams, DateTimeParams, DepartmentParams, EmailParams, EnumParams, and FileExtensionParams, along with a shared CommonOptions component for default/null/unique settings. Each component provides UI controls for specific data types (e.g., address regions, barcode formats, credit card types, date ranges) with live preview functionality and internationalization support for English, Chinese (Simplified/Traditional), and Japanese.

apps/desktop/src/components/generate/params · high confidence

Added a suite of new Vue components in the desktop app's message queue (MQ) section to provide comprehensive administration and monitoring capabilities. BrokerPanel displays cluster overviews and broker node details for systems like RocketMQ. ExchangesPanel enables the management of exchanges, including creating, deleting, and binding/unbinding queues with pagination and search. KafkaConsumerGroupsPanel visualizes consumer group states, member counts, and partition-level lag. KafkaMessagesPanel and MessageBrowser allow browsing topic stats, partition offsets, and peeking at messages with sorting and filtering. MessageQueryPanel and MessageTracePanel support querying messages by topic, key, or ID, and viewing trace details for RocketMQ. MonitoringPanel provides real-time charts for message rates, backlog, and latency, along with partition-level metrics. MqAdminConsole serves as the central hub, integrating these panels and managing tabs for tenants, namespaces, topics, subscriptions, and permissions.

apps/desktop/src/components/mq · high confidence

The metadata library now uses a structured caching system with in-flight request deduplication, scope-based invalidation, and persistent storage. This ensures that metadata loads are coordinated to avoid duplicate network calls, cached results are properly invalidated when underlying objects change, and expensive metadata queries are persisted to disk for faster subsequent loads.

apps/desktop/src/lib/metadata · high confidence

The desktop app now includes a new library in \apps/desktop/src/lib/naming\ that detects and converts identifier naming styles (camelCase, PascalCase, snake\_case, SCREAMING\_SNAKE\_CASE, kebab-case). The \namingStyleConverter\ provides a cycling conversion function (\convertToNextNamingStyle\) that transforms selected text through these styles in a fixed order, while \namingStyleTransformers\ allows direct conversion to any target style. The implementation uses a character-scan approach for word-boundary detection instead of lookbehind regexes to prevent crashes on legacy WebKit engines. These utilities handle edge cases like digit boundaries, leading/trailing separators, and non-identifier inputs gracefully, and are accompanied by comprehensive test coverage.

apps/desktop/src/lib/naming · high confidence

The object browser now includes dedicated UI components for inspecting and managing specific database objects. A new Database Browser lists databases with sortable columns (size, dates, charset) and context actions like setting the default database. Custom types (composite, enum, domain) are displayed in a tabbed panel showing members, properties, and DDL. PostgreSQL extensions can be installed or dropped via a management dialog, and event triggers show detailed metadata and DDL. These components provide deeper visibility and control over database schema objects directly from the desktop app.

apps/desktop/src/components/objects · high confidence

The table structure editor now includes dedicated UI components for managing table partitioning and physical storage options. The new TablePartitionsPanel displays a read-only, searchable, and collapsible tree of PostgreSQL partition nodes (strategy, bounds, and size estimates) within the structure properties. The TablePhysicalOptionsEditor provides an interactive interface for selecting partition and distribution columns, setting bucket counts, choosing storage formats, and toggling transactional mode, supporting databases like Inceptor that require these physical configurations.

apps/desktop/src/components/structure · high confidence

The \crates/dbx-plugin-runtime\ crate introduces a dedicated runtime layer for the plugin system, establishing the foundational infrastructure for plugin installation, lifecycle, and host interaction. This change adds provenance tracking to installed plugins, recording the source (marketplace, URL, or file) and signing key to prevent silent replacement during updates. It also implements a strict lifecycle management system that prevents plugin updates while active connections or operations are in progress, ensuring data consistency. The runtime exposes a comprehensive host API (version 1.4) supporting features like filesystem access, clipboard reads with consent, and schema metadata, while enforcing security constraints such as asset path validation and package size limits.

crates/dbx-plugin-runtime · high confidence

This change introduces several new capabilities in the query library: a confirmation code system (executionConfirmCode) that generates a 6-character alphanumeric code to prevent accidental multi-database batch executions; a multi-source result merger (multiSourceResult) that unions query results from multiple connections into a single table with a source column, column alignment, numeric summaries, and row capping; batch SQL recovery (batchSqlRecovery) that allows resuming failed SQL batches safely; a query result archive (queryResultArchive) that encodes and decodes query results into a compressed .dbxresults file for export/import; and utility functions for query output detection (queryOutput), pagination row stripping (queryPaginationResult), SQL Server temp table detection (queryResultCountSession), default view selection (queryResultDefaultView), error classification (queryResultError), and message extraction (queryResultMessages).

apps/desktop/src/lib/query · high confidence

The agents/scripts directory now includes a comprehensive suite of build and validation tools to standardize how DBX agents are packaged and verified for release. The new build\_driver\_zips.py script creates versioned, compressed tar.zst packages for both Java and native driver artifacts, while build\_offline\_zip.sh assembles platform-specific offline ZIP bundles containing the agent registry, JREs, drivers, and managed JDBC payloads. To ensure release integrity, build\_offline\_jdbc\_payload.mjs and verify\_offline\_jdbc\_release.mjs handle the resolution, validation, and checksum verification of approved JDBC bundles against a managed asset manifest. Additionally, validate\_agents.py and validate\_agent\_jars.py enforce architectural standards by checking for forbidden code patterns, ensuring JDBC agents use shared base classes, and verifying manifest attributes, while validate\_windows\_pe\_dependencies.py prevents Windows binaries from dynamically linking to the Visual C++ runtime.

agents/scripts · high confidence

Added a new \examples/\ directory containing runnable samples for common DBX workflows. This includes a CLI basic workflow script, MCP configuration files for Cursor and Claude Code (with centralized connection access policies), a Docker Compose file for self-hosted deployment, an etcd test bundle for configuration management, and a Web API automation script for HTTP-based interactions.

examples · high confidence

The backup settings panel now includes dedicated interfaces for configuring scheduled and one-shot database backups. Users can select specific database connections, define custom file name and run directory patterns with variable support, choose compression options, and filter by specific tables or databases. The interface also provides a searchable history view to filter past backup runs by connection, method, and status, along with controls to manage schedule enablement and run cancellation.

apps/desktop/src/components/backup · high confidence

The settings panel now includes a ChangelogPanel that renders release notes as markdown, a SettingsTransferPanel that enables exporting and importing settings as JSON files, and a suite of new components (McpAuthorizationStepper, McpConnectionScopePicker, McpDatabaseScopePicker, McpResourceScopePicker) that provide a guided, multi-step interface for configuring MCP connection, database, and resource scopes with fine-grained permissions. Tests were added to verify the stepper behavior and scope picker interactions.

apps/desktop/src/components/settings · high confidence

The \apps/desktop/src/lib/common\ directory now contains a suite of new shared modules that provide core functionality for the desktop app. These include \boundedTextPreview\ and \delayedPreview\ for managing text truncation and UI updates, \clipboard\ for handling cross-platform clipboard operations (including CRLF normalization on Windows and image support), and \safeJsonFormat\ for preserving large integer precision in JSON. Additional utilities cover color conversion (\color\), pinyin-aware search matching (\completionMatch\, \pinyin\), floating panel placement (\floatingPanelPlacement\, \floatingViewportPosition\), and UUID generation with secure context fallbacks (\utils\).

apps/desktop/src/lib/common · high confidence

The desktop app now features a new TableImportDialog component that guides users through a multi-step wizard for importing data into tables. This update adds support for batch imports (processing multiple files or Excel sheets in a single session) and allows users to import into existing tables or create new ones. For databases that support it (PostgreSQL, SQLite, DuckDB, etc.), users can configure conflict policies to handle duplicate rows during import. Additionally, DuckDB connections now support importing Parquet files, and the dialog includes options for text encoding, row ranges, and preserving empty strings.

apps/desktop/src/components/import · high confidence

Added a suite of new modules in the table library to support advanced table operations and metadata handling. This includes batch table drop and truncate execution with progress tracking, logic for PostgreSQL concurrent index creation availability, and MySQL-specific features such as auto-increment counter editing, storage engine management, collation handling, and event SQL generation. It also introduces object browser row actions for single/double-click behaviors, row caching with invalidation, and data type help for MySQL families.

apps/desktop/src/lib/table · high confidence

The desktop application introduces a comprehensive set of TypeScript type definitions to support new capabilities and integrations. The \ai.ts\ file defines the data model for the AI assistant, including provider configurations (e.g., Claude, OpenAI, CLI agents), effort levels, and chat state. New files for \consul.ts\, \nacos.ts\, \meilisearchManagement.ts\, \hbase.ts\, \influxdb.ts\, \mqtt.ts\, and \mq.ts\ provide type contracts for managing these specific services, including capabilities, connection configs, and data structures. Additionally, \governance.ts\ introduces types for audit trails, approval workflows, and drift detection, while \pluginAiTools.ts\ and \pluginData.ts\ define the interfaces for plugin-sourced AI tools and consent-gated data access.

apps/desktop/src/types · high confidence

The desktop app now includes a new ExplainPlanViewer component that provides multiple ways to inspect SQL execution plans. Users can switch between a visual canvas diagram (with zoom, pan, and heat-based cost highlighting), a collapsible node tree, a summary table, the raw plan output (JSON, XML, or text), and a standard MySQL-style table view. The viewer automatically selects the most appropriate view based on the database type and available data, and highlights discrepancies between estimated and actual row counts.

apps/desktop/src/components/explain · high confidence

The OceanBase Oracle agent now includes metadata and DDL generation for sequences, synonyms, and database links. This allows users to view, edit, and export these object types correctly, with synonyms preserving their target schema and DB link references, and sequences exporting their full configuration (min/max value, increment, cache, cycle/order flags).

agents/drivers/oceanbase-oracle/src/main · high confidence

The OceanBase Oracle driver now includes a UI preference to omit OceanBase-specific storage attributes (such as COMPRESS, REPLICA\_NUM, PCTFREE) from generated partition DDL by default, while preserving partition clauses and constraints. Additionally, the driver adds support for discovering and managing sequences, synonyms, and database links, including verifying that sequence edits do not reset counters and that database links are tenant-visible but manageable only by their creator.

agents/drivers/oceanbase-oracle · high confidence

The plugin management experience has been significantly updated with a new bottom dock for managing plugin workbenches, allowing users to open, rename, and reorder plugin tabs with drag-and-drop support. A new PluginAiAccessSection component gives users granular control over plugin permissions, including opt-in access to built-in AI tools and consent-gated data reads. The plugin marketplace and installed plugins view now features a polished card layout with sorting options, batch install/update actions, and improved connection forms with dynamic field options and local SSH key suggestions.

apps/desktop/src/components/plugins · high confidence

This change introduces the core frontend plugin infrastructure in the desktop app, starting with the FrontendPluginRegistry which indexes and resolves plugin contributions such as workbenches, result views, connection providers, and context menus. It adds plugin AI recommendations that interpolate context placeholders into safe, user-facing prompts, and a plugin appearance system that maps host design tokens (light/dark themes, fonts) into plugin sandboxes. Users can now perform batch install, update, and uninstall operations with progress tracking and partial failure reporting. The bottom dock provides a persistent, resizable panel for plugin-backed terminal sessions and connections, supporting tab management, drag-to-reorder, and singleton reuse logic. These components establish the plugin framework's UI and state management layer.

apps/desktop/src/lib/plugins · high confidence

The RabbitMQ agent implementation has been replaced from Java to Go. This new implementation adds support for bounded paging and sorting on queue and exchange management lists, preserves detailed queue metrics and features (such as message counts, queue type, and arguments), and correctly honors tunnel and management endpoint overrides for both AMQP connections and the management API.

agents/drivers/rabbitmq · high confidence

The Redis console now includes a new dashboard view that displays server information (such as memory, clients, and stats) with collapsible sections and auto-refresh options, and supports node selection in cluster mode. A new grouped key list component organizes keys into custom, sticky headers with virtualized scrolling to handle large datasets efficiently. Additionally, a dedicated JSON editor component provides syntax highlighting, folding, and search capabilities for viewing and editing JSON values.

apps/desktop/src/components/redis · high confidence

The \crates/dbx-driver-redis\ crate has been introduced, providing the core implementation for Redis database connectivity. This includes support for various Redis data types (strings, hashes, lists, sets, sorted sets, streams) and cluster/sentinel configurations. A key behavioral addition is the enforcement of a 4MB payload size limit on collection value pages (in addition to item count limits) to prevent excessive memory usage and UI lag when loading large sets or hashes, ensuring that large collections are paginated gracefully rather than causing timeouts or rendering issues.

crates/dbx-driver-redis · high confidence

The Redis key browser now includes a codec axis that can decode and display values stored in Base64, MessagePack, PHP serialize, Python pickle, Java serialization, and Protocol Buffers formats. Additionally, the viewer can decompress gzip and zlib payloads, with a strict 50 MB output cap and safe handling of raw deflate to prevent crashes or garbage display from zip bombs and arbitrary binary data.

apps/desktop/src/lib/redis · high confidence

The SAP HANA agent now includes column comments in generated table DDL statements, ensuring that metadata descriptions are preserved when recreating or inspecting table structures. Additionally, the agent can now retrieve the source definition for stored procedures by querying the SYS.PROCEDURES system catalog, allowing users to view procedure code directly within the agent interface.

agents/drivers/saphana · high confidence

Added SQL Server activity trace support for the desktop app, enabling users to capture and analyze database events via Extended Events. The implementation includes runtime management for starting, pausing, and stopping traces, along with automatic cleanup of stale sessions. A specific fix ensures that ARITHABORT is enabled during trace reads to prevent XML parsing errors, addressing a stability issue in the trace data retrieval process.

apps/desktop/src/lib/sqlserver · high confidence

The SQL file execution dialog now allows users to paste or type file paths directly into the input field (desktop mode), with support for multiple files separated by semicolons or newlines and automatic stripping of Windows-style quotes. Additionally, the dialog displays a byte-based progress indicator during SQL file imports, showing the percentage of bytes read and the current phase (preparing/executing), improving visibility into large file operations.

apps/desktop/src/components/sql-file · high confidence

The desktop library now includes built-in field mapping presets for migrating MySQL schemas to Dameng, PostgreSQL, and Oracle, automatically handling type conversions and parameter strategies. Additionally, query execution results now include detailed client-side timing metrics (preparation, request wait, and result processing times) to help users understand performance characteristics across different database operations.

apps/desktop/src/lib · high confidence

Users can now export and import their application settings as a versioned JSON file, allowing for easy backup and migration of configuration across installations. The settings interface also features a global search capability that lets users quickly locate specific options across all categories, including editor, appearance, and data settings, without manually browsing through menus.

apps/desktop/src/lib/settings · high confidence

The sidebar now supports keyboard navigation using arrow keys to move between and expand/collapse tree nodes, and allows sorting the connection list alphabetically or manually. A new batch table emptying feature lets users clear multiple selected tables in one operation, and the connection list can be sorted by name. Additionally, the login user's schema is highlighted in Oracle-family databases to help users identify their current context.

apps/desktop/src/lib/sidebar · high confidence

The sidebar connection tree has been rebuilt with a new component architecture, introducing a dedicated ActiveConnectionFilterButton to toggle visibility of active connections, a SidebarLocateButton to find the currently active tab's node in the tree, and a SidebarRegexToggleButton to enable regular expression search. The layout now features a SidebarListOptionsIcon that animates between filter and settings states, and the tree supports nested virtual table groups via a new SidebarTableVGroupDialog for organizing and moving tables. These changes refine the sidebar's search, navigation, and object management capabilities.

apps/desktop/src/components/sidebar · high confidence

The DuckDB database support is now provided as a standalone Rust sidecar driver (\dbx-duckdb-driver\) that runs separately from the main application, keeping the DuckDB dependency isolated. On Windows, the driver statically links the Visual C++ runtime to ensure it runs on fresh installations without requiring a separate redistributable package. The driver now correctly preserves DML \RETURNING\ rows, handles \CURRENT\_DATE\ arithmetic literals, and formats \timestamptz\ values using the session time zone. It also includes robust connection management that explicitly closes connections to release file locks and checkpoints the WAL on shutdown, preventing "file already in use" errors and handling connection poisoning from syntax errors.

agents/drivers/duckdb · high confidence

Users can now export database documentation as a single, self-contained HTML file that renders offline. This standalone viewer includes controls to switch between light and dark themes and change the display language (supporting English, Spanish, Italian, Japanese, Korean, Portuguese, and Simplified/Traditional Chinese), while preserving navigation via URL hashes and ensuring correct accessibility attributes like the HTML lang attribute. The export bundle handles payload decoding, translation fallbacks, and error messaging for corrupted files without requiring an internet connection or the main application.

apps/desktop/src/docs-export · high confidence

Users can now import database connections from popular third-party tools. The desktop app adds dedicated importers for DataGrip (preserving groups and Kingbase connections), DBeaver (preserving folder structures and mapping DB2 drivers correctly), and Navicat (decrypting passwords, importing SSH tunnel settings, and rebuilding MongoDB replica-set URLs).

apps/desktop/src/lib/imports · high confidence

The new SqlServerLegacyAgent enables connections to legacy SQL Server 2000 instances and older endpoints that require deprecated TLS ciphers (such as TLS 1.0/1.1 and RSA-based suites). It implements a fallback mechanism that switches from the standard Microsoft JDBC driver to the jTDS driver when modern driver prelogin attempts fail, ensuring compatibility with older server versions. The agent also handles legacy-specific behaviors, including normalizing NUL-padded character values, retrieving views and triggers via legacy system tables, and preserving explicit instance ports.

agents/drivers/sqlserver-legacy · high confidence

The TDengine agent has been replaced with a new native Rust implementation (replacing the previous Java agent). This new driver uses the \taos\ Rust WebSocket connector to handle connections, supporting both standard and legacy JDBC-style connection strings (e.g., \jdbc:TAOS-WS://\, \taosws://\) and automatically upgrading them to WebSocket schemes (\ws\/\wss\). It introduces stable table listing by caching and sorting results locally to prevent pagination issues, preserves FLOAT decimal precision in query results, and correctly formats timestamps with timezone awareness and full sub-second precision (milliseconds, microseconds, nanoseconds). The agent communicates via a JSON-RPC 2.0 protocol over stdin/stdout, supporting capabilities like paged queries, structured errors, and session management.

agents/drivers/tdengine · high confidence

The history module now supports a unified view that includes Model Context Protocol (MCP) SQL executions alongside standard database queries. It introduces classification logic to categorize entries as queries, data changes, or schema changes, and adds filtering capabilities based on connection, database, and date range. The system also identifies MCP-specific entries via source metadata and provides utilities for resolving restore targets and validating rollback safety.

apps/desktop/src/lib/history · high confidence

The new YashanDB database agent now supports retrieving the source code for functions and procedures via the ALL\_SOURCE view, allowing users to inspect these object definitions. Additionally, it correctly reads structured values (such as ST\_GEOMETRY and custom UDTs) by materializing them as JDBC Struct objects and normalizing their attributes into a readable string format, avoiding errors that occurred when attempting to access them as simple strings.

agents/drivers/yashandb · high confidence

The ZooKeeper driver has been replaced with a native Go implementation, introducing support for TLS-secured connections (via CA, client certificate, and key paths) and SASL-DIGEST-MD5 authentication. The new agent also handles large children responses safely, supports recursive deletion of non-empty znodes, and exposes server version information through the connection info endpoint.

agents/drivers/zookeeper · high confidence

The \src/lib\ directory has been cleaned up by deleting \ai.ts\, \tauri.ts\, and \utils.ts\. This removes the previous direct HTTP-based SQL generation logic, the Tauri command invocation layer for database/Redis/MongoDB operations, and the Tailwind CSS class merging utility, indicating a shift away from these specific implementation patterns in the application's core library.

src/lib · high confidence

The DBX Web server now includes a new authentication system (auth.rs) that supports password setup, login with rate limiting, and session management, along with a demo mode (demo.rs) that restricts dangerous operations like credential changes, plugin installation, and connection testing to prevent SSRF and unauthorized state changes in public deployments. Additionally, error responses are standardized (error.rs) to preserve backend diagnostic details while redacting sensitive information, and the main application (main.rs) integrates these security features with migration gates and static asset serving.

crates/dbx-web · high confidence

The Tauri IPC command handlers for Consul operations (such as KV operations, sessions, ACLs, and mesh configuration) have been extracted from the main application into the new \dbx-tauri-consul\ crate. This change isolates the Consul-specific command registration and routing logic, ensuring that only commands prefixed with \consul\_\ are handled by this module while other commands continue to be processed by the main handler.

crates/dbx-tauri-consul · high confidence

A new \dbx-driver-postgres\ crate has been added to the workspace, consolidating PostgreSQL-specific database driver logic. This module exposes core database operations, SQL parsing, and type handling via re-exports from supporting crates (\dbx\_driver\_support\, \dbx\_sql\_core\, \dbx\_types\), while implementing the primary \postgres\ module to manage connections, queries, and schema introspection for PostgreSQL databases.

crates/dbx-driver-postgres · high confidence

The monolithic App.vue component and the main.ts entry point have been removed from the src directory. This change extracts the application's core logic, state management, and UI composition into separate composables and layout components to improve readability and maintainability, as part of a broader effort to centralize database feature capabilities and refactor the frontend structure.

src · high confidence

The AI assistant now distinguishes between 'Ask' and 'Agent' modes with separate action menus: Ask mode is limited to SQL-producing actions (like generate, explain, optimize) that never auto-run, while Agent mode includes task-oriented actions (query, exploreSchema, executeAndExplain) that drive tool use. The Agent mode now features a structured execution plan that includes risk checks for SQL writes, requiring explicit user confirmation for potentially dangerous operations and blocking them based on policy. Additionally, conversations are now bound to specific database connections and schemas, preventing context leakage between different databases, and the system supports auto intent routing where the assistant can select the appropriate action at send time.

apps/desktop/src/lib/ai · high confidence

Query execution times are now displayed using adaptive units that scale based on duration: sub-second values show integer milliseconds, values up to one minute show one decimal second, and longer durations display minutes and seconds (or hours, minutes, and seconds for durations over an hour). This replaces raw millisecond readouts with more readable formats, and also supports formatting server-side execution times reported in microseconds.

apps/desktop/src/lib/format · high confidence

The pre-commit hook now automatically formats staged Rust files using \cargo fmt\ before committing. This change ensures consistent code style by running the formatter on Rust files within the \src-tauri\, \crates/dbx-core\, and \crates/dbx-web\ directories, re-adding them to the staging area if modifications are made.

.husky · high confidence

The desktop application now translates backend and AI CLI error messages into the user's selected language. Previously, errors from components like the Phoenix driver, plugin updates, proxy tunnels, and AI providers (Claude Code, Cursor, Grok, etc.) were shown in English regardless of locale settings. This change introduces a mapping layer in \apps/desktop/src/i18n/backend-errors.ts\ that converts raw error strings and patterns into i18n keys, ensuring users see localized feedback for connection issues, driver installation prompts, and agent configuration errors.

apps/desktop/src/i18n · high confidence

The application now uses a dedicated Pinia store to coordinate connection password prompts. This change introduces a queuing mechanism that ensures concurrent connection attempts share a single password dialog, preventing multiple overlapping prompts and ensuring each request is answered exactly once.

apps/desktop/src/stores · high confidence

The DBX CLI has migrated from a Node.js-based implementation to a native Rust binary, available via npm, Homebrew, or direct platform-specific downloads. This change eliminates the Node.js runtime requirement for the core CLI tool, improving startup performance and reducing dependencies. The new binary includes an official DBX Agent Skill that can be installed and managed offline using \dbx agent setup\, enabling shell-capable AI agents to interact with database connections directly. The CLI maintains compatibility with existing DBX connection storage and supports direct queries for PostgreSQL, MySQL, and SQLite, while bridging to DBX Desktop for other database types.

packages/cli · high confidence

The Databend database agent now lists and retrieves source for stored procedures in addition to tables and views, allowing users to inspect procedure metadata and definitions. It also fixes a bug where database names containing underscores (e.g., my\_db) returned no results by disabling schema wildcard escaping, which was incorrectly treating underscores as wildcards.

agents/drivers/databend · high confidence

The desktop application now includes a dedicated entry point (index.html) that applies the user's saved theme and corner style preferences before the main application loads, and guards against premature keyboard input during startup. The Vite build configuration has been updated to support context path deployments via a public base path redirect plugin, and the TypeScript configuration now excludes test files from type checking to improve build performance.

apps/desktop · high confidence

The table selection behavior for the schema diff feature has been extracted into a new, framework-agnostic module (\tableMultiSelect.ts\). This change introduces pure helper functions for filtering table names by query, toggling individual table selections, and bulk-selecting or deselecting filtered results. By decoupling this logic from the UI framework, the same selection behavior is now shared between the Data Compare and Schema Diff features, ensuring consistent user experience and enabling independent unit testing of the selection mechanics.

apps/desktop/src/lib/diff · high confidence

The GridFS browser now supports bulk downloading of files as a ZIP archive and paged browsing, addressing previous limitations with large datasets. Document grid column visibility is now persisted per connection and collection, with an automatic migration from the legacy storage format. Query totals are more accurate, using exact counts for incomplete pages and clamping Elasticsearch page sizes to the default max\_result\_window to prevent errors.

apps/desktop/src/lib/document · high confidence

Users can now delete rows from InfluxDB 1.x connections via the result grid, but only when the operation is strictly guarded. The new \influxDbV1Delete\ module ensures safety by requiring explicit column role metadata (time, tag, field), verifying that the result shape matches the schema exactly, and validating timestamp formats (including nanosecond precision). It prevents accidental deletion of stale, ambiguous, or non-unique points and rejects any attempt to route inserts or updates through the delete path.

apps/desktop/src/lib/influxdb · high confidence

The Hive agent in agents/go-common/gohive has been rewritten in native Go, replacing the previous implementation. This migration introduces a standard database/sql driver interface (driver.Connector) and a new DSN parser for connection configuration. It adds support for HTTP transport mode, including Browser SSO authentication via a local loopback callback, and HTTP noSasl connections using Basic auth. The agent now uses a legacy-compatible HiveServer2 protocol version (V6) for session opening and provides new metadata capabilities (GetSchemas, GetTables, GetColumns, GetTypeInfo) accessible via the MetadataProvider interface.

agents/go-common/gohive · high confidence

The dbx CLI has been rewritten in native Rust, replacing the previous implementation. This release bundles the official DBX agent skill (version 1.1.0) directly into the binary, allowing users to install, update, or check the status of the agent skill via the new \dbx agent setup\ and \dbx agent status\ commands. The CLI now includes robust runtime parameter validation, distinguishes between missing connection tables and failed store opens for clearer error reporting, and installs the \aws\_lc\_rs\ crypto provider by default to prevent \rustls\ panics.

crates/dbx-cli · high confidence

The desktop application now features a new, unified \KvKeyBrowser\ component that powers key management across supported backends (including ZooKeeper). This component introduces true lazy loading for key trees to improve performance with large datasets and includes a CodeMirror-based value editor with syntax highlighting for formats like JSON, YAML, and SQL. A critical behavioral change ensures that internal agent error payloads (such as etcd contract details) are sanitized and hidden from users in browser messages, displaying only the user-facing error text. The ZooKeeper integration specifically leverages this new browser to provide Base64 UTF-8 value previews and localized node actions.

apps/desktop/src/components/kv · high confidence

The \agents/go-common/gosasl\ package now provides a native Go implementation of the SASL protocol, replacing the previous Java-based agent. This library supports GSSAPI (Kerberos), DIGEST-MD5, PLAIN, and ANONYMOUS mechanisms. It features a pure-Go Kerberos backend for non-Windows platforms and a Windows SSPI backend for Windows, allowing agents to authenticate to services like Zookeeper and Hive without external Java dependencies. Additionally, the package includes an \SPNEGORoundTripper\ that enables HTTP-based Negotiate authentication with TLS channel binding support.

agents/go-common/gosasl · high confidence

The Neo4j agent in this location has been replaced with a native Go implementation using the official Neo4j Go Driver v6, removing the previous JDBC dependency. This change introduces a compatibility fix for older single-instance servers (such as Neo4j 3.5) that do not support cluster routing: if a \neo4j://\ routing connection fails, the agent automatically falls back to a direct \bolt://\ connection. The new driver also supports TLS via CA certificates and client certificates, manages connection pooling with a 1 MiB read buffer, and handles metadata discovery using Neo4j 5.x-compatible procedures while retaining previous query result behaviors.

agents/drivers/neo4j-go · high confidence

The desktop MQ console now supports searching loaded Kafka messages by any visible field (including headers and Base64 payloads) and sorting them by publish time with stable handling of missing or invalid timestamps. Console tabs and features are now driven by a capabilities model that correctly exposes RabbitMQ-specific capabilities (exchanges, policies, user permissions, client connections) and RocketMQ capabilities (message query, trace, DLQ) while restricting others. Utility functions for parsing RocketMQ consumer group types, trace payloads, and queue feature badges have been added to improve display accuracy across systems.

apps/desktop/src/lib/mq · high confidence

The etcd driver has been rewritten in Go to replace the previous Java implementation, introducing protocol version 2 and full support for etcd v3. This new agent enforces key browsing and write restrictions based on the authenticated user's permissions, ensuring that operations are limited to the specific key ranges granted by the user's roles rather than attempting global enumeration. It maintains byte-for-byte parity with the Java agent's error signals and capability strings while adding support for features like custom lease IDs and improved watch budgeting.

agents/drivers/etcd-go · high confidence

This change removes several legacy Vue components from the src/components directory, including the ConnectionDialog, AiAssistant, DangerConfirmDialog, QueryEditor, QueryHistory, DataGrid, DatabaseIcon, MongoDocBrowser, RedisKeyBrowser, RedisValueViewer, ConnectionTree, and TreeItem. These deletions indicate a significant architectural shift, likely replacing the previous inline implementations with new, centralized, or refactored versions elsewhere in the application. Users will experience a streamlined codebase as these specific file artifacts are eliminated, paving the way for the updated connection handling, AI assistant integration, and data grid behaviors described in other changelog entries.

src/components · high confidence

The key-value store library has been reorganized into distinct modules to improve maintainability and clarity. New files introduce structured error handling for etcd and general mutations, dedicated logic for building and managing key trees (including lazy loading and path normalization for ZooKeeper and Consul), and utilities for metadata refresh, search, and export scoping. Value display and formatting capabilities have been expanded to support syntax detection and validation for JSON, YAML, XML, SQL, Dockerfile, Nginx, and Kubernetes, alongside improved base64 preview and JSON pretty-printing.

apps/desktop/src/lib/kv · high confidence

The global stylesheet (src/styles/globals.css) has been deleted, removing the application's base CSS reset, Tailwind CSS imports, font definitions (Geist), and all light/dark mode color variables. This change eliminates the centralized styling layer that previously defined the visual theme and layout rules for the entire application.

src/styles · high confidence

The application has removed the previous Pinia-based state management files for connections, query history, query tabs, and AI settings. This cleanup eliminates the old in-memory and localStorage-backed store implementations, indicating a migration to a new architecture or state management approach for these core features.

src/stores · high confidence

The legacy i18n implementation using vue-i18n has been removed from the codebase. This change deletes the main i18n configuration file and the specific English (en) and Simplified Chinese (zh-CN) locale definition files that previously handled UI string translation and locale switching via local storage.

src/i18n · high confidence

The \src/types/database.ts\ file has been deleted, removing the previous TypeScript definitions for database types, connection configurations, and tree node structures. This change indicates a migration away from the hardcoded set of supported databases (MySQL, PostgreSQL, SQLite, Redis, DuckDB, ClickHouse, SQL Server, MongoDB) and the associated legacy data models for connections, tables, columns, and query results.

src/types · high confidence

The saved SQL library has been refactored to support managing queries by database, including batch connection and database changes, and running queries in the current database. New modules handle database-scoped tree building (with the Queries node collapsed by default), batch target reassignment, clipboard operations, directory imports, and history ranking. This ensures SQL files are properly associated with their target databases and visible in the sidebar.

apps/desktop/src/lib/savedSql · high confidence

The \dbx-tauri-schema\ crate now provides a centralized registry for all database schema-related operations (such as listing databases, tables, schemas, and indexes). This change introduces a \route\ function that intercepts Tauri IPC calls matching specific schema commands and dispatches them to the appropriate handlers, while passing all other commands to the main application handler. This ensures that schema-specific logic is isolated and consistently managed within this crate.

crates/dbx-tauri-schema · high confidence

This change introduces a comprehensive system for preserving tab state across switches and sessions, including a configurable data tab reuse mode (always-new, same-table, active-tab) and logic to handle tab retention when connections are deleted. It adds a JetBrains-style Ctrl+Tab switcher with MRU ordering, navigation history shortcuts, and a tab close action menu supporting batch operations (close others, close right/left, close all). To prevent data loss and race conditions, the system now caches document browser, Redis key browser, and query result states (with size limits and eviction policies) and uses navigation tokens to discard stale requests. Additional refinements include stable numeric suffixes for duplicate tab titles, an adaptive SQL editor toolbar that condenses controls based on available width, and debounced UI state tracking to optimize performance.

apps/desktop/src/lib/tabs · high confidence

The \vendor/webview2-com-sys\ crate has been updated with new bindings generated by \windows-bindgen\ 0.62.1. This update refreshes the low-level FFI definitions for the WebView2 loader, including functions like \CompareBrowserVersions\ and \CreateCoreWebView2Environment\, as well as constants and structs for browser process exit kinds, browsing data kinds, and channel search kinds. The change also includes a test module verifying the \CompareBrowserVersions\ function's equality and ordering logic, ensuring the updated bindings correctly interface with the underlying \webview2loader\ library.

vendor/webview2-com-sys · high confidence

The \dbx-formats\ crate now ensures that NULL values are exported as the literal \\\N\ in CSV and TSV files, preventing them from being mistaken for empty strings during import. Large SQL exports are now packaged into split ZIP archives that preserve statement boundaries across parts, ensuring each part is independently valid and replayable. Additionally, high-precision numbers in XLSX exports are preserved as text to prevent Excel from rounding or altering their displayed values.

crates/dbx-formats · high confidence

The desktop app now detects and accommodates legacy WebKit engines (macOS 12 and earlier) to prevent startup crashes and ensure correct UI rendering. A new \legacyWebView\ module probes for modern CSS capabilities (such as \oklch\, \color-mix\, and \:has\) and regex lookbehind support; if these are missing, it applies a \dbx-legacy-webview\ class to the root element to trigger fallback styles. Additionally, a build-time check ensures that bundled source files do not contain regex lookbehind assertions (except in the detection probe itself), preventing the SyntaxError that previously killed the app on old WebKit versions.

apps/desktop/src/lib/ui · high confidence

The new Highgo database agent ensures that the public schema remains accessible when switching search paths. Unlike the default behavior which might replace the entire search path, this agent appends 'public' to the SET search\_path command for non-public schemas, preventing loss of access to standard public functions and objects.

agents/drivers/highgo · high confidence

The IRIS database agent now displays %Boolean columns as their stored 1/0 integer values instead of true/false, and reads integer columns using BigDecimal to preserve values that exceed Java's primitive integer range. It also increases the JDBC query prefetch size to 256KB to improve performance for large result sets over high-latency connections, and improves primary key detection by falling back to native IRIS queries when standard JDBC metadata is unavailable.

agents/drivers/iris · high confidence

The Tiberius SQL Server driver now handles previously problematic data scenarios more gracefully: rows remain readable when collation decoding fails, malformed UTF-16 row values are tolerated instead of causing errors, and legacy CP437/CP850 collations are properly decoded.

vendor/tiberius · medium confidence

Added a dedicated CSS file to fix layout and styling issues in older WebKit-based WebView environments. This change ensures that connection dialog components, such as the database picker grid and form layouts, render correctly by providing explicit width, height, and flex-box rules that older browsers may ignore when using modern CSS range syntax or Tailwind-generated classes.

apps/desktop/public · high confidence

The desktop app now includes robust mechanisms to handle startup failures and track performance. A new authentication check validates the user's session state early in the process, while a preload recovery system automatically retries the application if CSS preloading fails, preventing indefinite hangs. Additionally, startup timing marks are now recorded for key phases (such as bootstrap, auth-ready, and tabs-restored) to enable performance monitoring and faster diagnosis of slow starts.

apps/desktop/src/lib/startup · high confidence

The agent runtime now uses a shared JDBC connection pool registry to reuse connections across sessions, reducing overhead and improving stability. A new structured error classification system (AgentRpcError) maps JDBC and runtime exceptions into categorized, retryable, or quarantine-bound responses, giving clients clearer signals on connection health and error recovery. Additionally, batch execution now safely falls back to individual statement execution when the underlying JDBC driver does not support batch operations, ensuring consistent behavior across diverse database drivers.

agents/common/src/main/java · high confidence

The vendor directory now includes the \rust-ctor\ crate, providing \\#\[ctor\]\ and \\#\[dtor\]\ macros for module initialization and teardown across supported platforms. Additionally, \dirs-sys\ has been vendored and patched specifically for Windows 7: it now links \CoTaskMemFree\ directly from \ole32.dll\ instead of relying on \combase.dll\ (via \windows-sys\), which is unavailable on Windows 7, ensuring the application starts correctly on that legacy OS.

vendor · high confidence

Added JDBC agent test support infrastructure; Added comprehensive i18n test coverage for desktop locale parity and error translation; Added contract and integration tests for backend transport and storage layers; Added test coverage for Nacos access control, admin console, and config management components; Added test coverage for database import parsers; Added test coverage for editor and AI assistant components; Added test environment configuration for timezone handling; Added tests for AI assistant core logic and UI components; Added tests for Dameng agent metadata, paging, and connection handling; Added tests for Data Grid component behaviors; Added tests for Elasticsearch request formatting; Added tests for Elasticsearch response panels, JSON tree virtualization, and query error actions; Added tests for Explain Plan visualization components; Added tests for H2 agent driver lifecycle and multi-version support; Added tests for KV store key tree, metadata refresh, and value display logic; Added tests for Kafka agent resolver, consumer group logic, and SASL compatibility; Added tests for MCP configuration templates, policy selection, and server management; Added tests for MongoDB shell text formatting; Added tests for Nacos configuration validation, YAML linting, and dashboard metrics; Added tests for ObjectBrowser and CustomTypeInfoPanel components; Added tests for PasswordInput tab order behavior; Added tests for Redis value presentation, auto-refresh, and monitoring logic; Added tests for SQL DDL display, storage, and rich-text copy features; Added tests for SQL editor core behaviors; Added tests for SQL semantic analysis and completion; Added tests for VectorBrowser component request generation and schema handling; Added tests for ZooKeeper connection, API contract, and lazy key tree logic; Added tests for app theme normalization, document store providers, tab persistence, and sidebar pinning; Added tests for common utility functions; Added tests for connection handling logic; Added tests for connection library modules; Added tests for data grid cell handling, row management, and query limits; Added tests for database backup logic; Added tests for database feature support, production safety guards, and read-only write access controls; Added tests for desktop app background, theme, and windowing logic; Added tests for desktop composables and UI behaviors; Added tests for diagram comment layout, SQL identifier parsing, MySQL explain compatibility, and execution plan canvas logic; Added tests for document grid column visibility storage and query total resolution logic; Added tests for editor, database, and platform-specific logic; Added tests for import source preview logic; Added tests for layout components and behaviors; Added tests for legacy WebView CSS fallbacks and cascade assembly; Added tests for metadata completion policies and tree indexing; Added tests for ordered list selection logic; Added tests for plugin batch operations; Added tests for plugin batch operations, icon caching, deep links, analytics, and pinning; Added tests for query batch recovery and database-specific explain plan parsing; Added tests for query result export naming logic; Added tests for saved SQL library management logic; Added tests for schema diff selection, filtering, and metadata loading; Added tests for settings draft, search, and transfer logic; Added tests for sidebar tree and data tab behaviors; Added tests for startup gate, input guard, authentication, preload recovery, and timing; Added tests for tab state caching, UI state, and switching logic; Added tests for table management and object browser logic; Added tests for table metadata, clipboard, and grouping logic; Added tests for the SSH host key prompt dialog; Added tests for the Security Migration Wizard's error handling and diagnostic export; Added tests for the desktop update center's component update logic; Added unit tests for AI chat logic and configuration; Added unit tests for Document Browser and MongoDB import/export dialogs; Added unit tests for OceanBase Oracle agent connection and query behavior; Added unit tests for SQL editor extensions and utilities; Added unit tests for common utility modules; Added unit tests for connection activation guards and agent driver install hints; Added unit tests for connection store logic; Added unit tests for database administration and configuration logic; Added unit tests for desktop MQ library modules; Added unit tests for metadata caching and tree load management; Added unit tests for the data transfer component suite; Expanded test coverage for Data Grid rendering, formatting, and data handling; Expanded test coverage for JDBC agent core components; Expanded test coverage for SQL editor logic and formatting; Expanded test coverage for sidebar components and behaviors; New schema-diff library and test coverage.

The repository now includes prebuilt dependency caches for Windows 7 to speed up CI builds. New Cargo fixtures for \win7-aws-lc-cache\ and \win7-openssl-cache\ pin \aws-lc-sys\ (0.43.0) and \openssl-sys\ (0.9.117) respectively, alongside the root \Cargo.lock\ and \Cargo.toml\ which define the workspace and patch dependencies like \wry\ and \tauri-plugin-updater\ for Win7 compatibility.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 53 → 55 (+1.5)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 63 → 65 (+2.0)
• Architecture 62 → 69 (+7.4)
• Maturity 67 → 71 (+4.1)
• Readiness 55 → 61 (+6.3)
• Security 61 → 67 (+5.4)
• Event-Driven 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 44 → 44 (+0.1)
• Performance 60 (new)

• AgentDriverClient::call_typed_with_timeout_and_cancel (cognitive 21) (crates/dbx-core/src/db/agent_driver.rs)
• AgentDriverClient::call_typed_with_timeout_and_cancel (cyclomatic 16) (crates/dbx-core/src/db/agent_driver.rs)
• AgentManager::collect_driver_store_usage (cognitive 21) (crates/dbx-core/src/agent_manager.rs)
• Analyzer::visit_expr (cyclomatic 24) (crates/dbx-core/src/sql_analysis.rs)
• AppState::get_or_create_pool_for_session_inner (cognitive 160) (crates/dbx-core/src/connection.rs)
• AppState::get_or_create_pool_for_session_inner (cyclomatic 90) (crates/dbx-core/src/connection.rs)
• AppState::insert_connection_pool_inner (cognitive 18) (crates/dbx-core/src/connection.rs)
• AppState::refresh_connections (cognitive 81) (crates/dbx-core/src/connection.rs)
• AppState::refresh_connections (cyclomatic 55) (crates/dbx-core/src/connection.rs)
• AppState::remove_stale_connection_pool (cognitive 50) (crates/dbx-core/src/connection.rs)
• AppState::remove_stale_connection_pool (cyclomatic 52) (crates/dbx-core/src/connection.rs)
• AppState::start_keepalive_task (cognitive 58) (crates/dbx-core/src/connection.rs)
• AppState::start_keepalive_task (cyclomatic 22) (crates/dbx-core/src/connection.rs)
• Change coupling: DataGrid.vue ↔ tabResultCache.ts (apps/desktop/src/components/grid/DataGrid.vue)
• Change coupling: DriverStoreDialog.vue ↔ plugins.rs (apps/desktop/src/components/config/DriverStoreDialog.vue)
• Change coupling: agent_connection.rs ↔ agent_runtime.rs (crates/dbx-core/src/agent_connection.rs)
• Change coupling: columns.rs ↔ tests.rs (crates/dbx-core/src/table_structure_sql/columns.rs)
• Change coupling: connectionPresentation.ts ↔ connection.rs (apps/desktop/src/lib/connection/connectionPresentation.ts)
• Change coupling: connection_secrets.rs ↔ query.rs (crates/dbx-core/src/connection_secrets.rs)
• Change-coupling hub: ConnectionDialog.vue → DatabaseIcon.vue, DatabaseSearchDialog.vue, agent_catalog.rs, connection_secrets.rs, database_capabilities.rs (apps/desktop/src/components/connection/ConnectionDialog.vue)
• …and 1829 more

• AbstractJdbcAgent.finishPooledRequest (cognitive 16) (agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java)
• AbstractJdbcAgent.finishPooledRequest (cyclomatic 16) (agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java)
• AgentDriverClient::call_typed_with_timeout_and_cancel (cognitive 21) (crates/dbx-driver-agent/src/agent_driver.rs)
• AgentDriverClient::call_typed_with_timeout_and_cancel (cyclomatic 16) (crates/dbx-driver-agent/src/agent_driver.rs)
• AgentManager::collect_driver_store_usage (cognitive 21) (crates/dbx-driver-agent/src/agent_manager.rs)
• Analyzer::visit_expr (cyclomatic 24) (crates/dbx-sql-core/src/sql_analysis.rs)
• AppState::get_or_create_pool_for_session_inner (cognitive 162) (crates/dbx-core/src/connection/mod.rs)
• AppState::get_or_create_pool_for_session_inner (cyclomatic 95) (crates/dbx-core/src/connection/mod.rs)
• AppState::insert_connection_pool_inner (cognitive 18) (crates/dbx-core/src/connection/mod.rs)
• AppState::refresh_connections (cognitive 87) (crates/dbx-core/src/connection/mod.rs)
• AppState::refresh_connections (cyclomatic 60) (crates/dbx-core/src/connection/mod.rs)
• AppState::remove_stale_connection_pool (cognitive 54) (crates/dbx-core/src/connection/mod.rs)
• AppState::remove_stale_connection_pool (cyclomatic 57) (crates/dbx-core/src/connection/mod.rs)
• AppState::start_keepalive_task (cognitive 58) (crates/dbx-core/src/connection/mod.rs)
• AppState::start_keepalive_task (cyclomatic 22) (crates/dbx-core/src/connection/mod.rs)
• BackupSchedule::next_after (cognitive 17) (crates/dbx-core/src/scheduled_backup/models.rs)
• BackupService::cleanup (cognitive 19) (crates/dbx-core/src/scheduled_backup/service.rs)
• BackupService::command (cyclomatic 16) (crates/dbx-core/src/scheduled_backup/service.rs)
• BackupService::export_job (cognitive 101) (crates/dbx-core/src/scheduled_backup/engine.rs)
• BackupService::export_job (cyclomatic 40) (crates/dbx-core/src/scheduled_backup/engine.rs)
• …and 3357 more

• 300 commits — 118 feature/other, 182 fixes

• apps/desktop — 168 commits
• crates/dbx-core — 31 commits
• agents/drivers — 20 commits
• (root) — 13 commits
• crates/dbx-drivers — 8 commits
• agents/versions.json — 6 commits
• docs/data — 6 commits
• src-tauri/src — 6 commits
• .github/scripts — 5 commits
• crates/dbx-sql-dialect — 4 commits
• crates/dbx-driver-agent — 3 commits
• crates/dbx-driver-mysql — 3 commits
• crates/dbx-plugin-runtime — 3 commits
• docs/content — 3 commits
• crates/dbx-driver-postgres — 2 commits
• crates/dbx-sql-data — 2 commits
• crates/dbx-sql-schema — 2 commits
• packages/app-tests — 2 commits
• (repo) — 1 commit
• .github/workflows — 1 commit

• fix: fix(agent): install sqlite ssh worker per remote arch from offline zip
• fix: fix(agent): release external Windows process locks
• fix: fix(ai): compact composer controls based on overflow
• fix: fix(ai): improve responsive composer controls
• fix: fix(ai): initialize conversation bindings before default action selection
• fix: fix(cassandra): return materialized view definitions
• fix: fix(cassandra): use cursor pagination for table data and exports
• fix: fix(ci): refresh standalone DuckDB lockfile
• fix: fix(ci): remove unused storage imports breaking clippy gate
• fix: fix(cli): distinguish missing connections table from failed store open
• fix: fix(completion): keep FROM tables across blank lines in one statement
• fix: fix(connection): per-id saves stop cross-client connection clobber
• fix: fix(core): cache resolved secret codec per storage instance
• fix: fix(core): drop needless return in test secret key path
• fix: fix(core): gate default secret key path resolution out of test builds
• fix: fix(core): isolate Linux keyring access from async runtimes
• fix: fix(core): stop no-keyring builds creating the global fallback key
• fix: fix(dameng): reject binary LOB columns in keyless row predicates
• fix: fix(dameng): resolve empty schema via session current schema
• fix: fix(dameng): show declared char/byte length unit in table structure
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

t8y2/dbx was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.