mcp-read-only-sql 0.2.2__tar.gz → 0.2.6__tar.gz

{mcp_read_only_sql-0.2.2 → mcp_read_only_sql-0.2.6}/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project aims to follow [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.6] - 2026-06-08
+
+### Fixed
+
+- Resolved the `psql` / `clickhouse-client` CLI binaries through an explicit lookup (env override → `PATH` → OS-aware fallback) instead of relying solely on `PATH`. Homebrew keg-only `libpq` installs on macOS, where `psql` is not symlinked onto `PATH`, now work without manual `PATH` setup. The resolved path can be pinned with `MCP_READ_ONLY_SQL_PSQL_PATH` / `MCP_READ_ONLY_SQL_CLICKHOUSE_CLIENT_PATH`, and is cached per connector.
+
+## [0.2.5] - 2026-04-21
+
+### Added
+
+- Added hot-reload regression tests covering connection add/change/remove flows, invalid live edits, and config changes that happen during a reload attempt.
+
+### Fixed
+
+- Reloaded `connections.yaml` automatically before both `list_connections` and `run_query_read_only`, without requiring an MCP server restart.
+- Kept hot-reload state atomic by building connectors from a single file snapshot and only storing a config marker for the exact snapshot that was actually loaded.
+- Preserved the last known good connections when live config edits are invalid or the config file is temporarily missing, while continuing to retry reloads on later tool calls.
+
 ## [0.2.2] - 2026-04-03
 
 ### Added

{mcp_read_only_sql-0.2.2 → mcp_read_only_sql-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-read-only-sql
-Version: 0.2.2
+Version: 0.2.6
 Summary: MCP server for read-only SQL queries supporting PostgreSQL and ClickHouse
 Project-URL: Homepage, https://github.com/lukleh/mcp-read-only-sql
 Project-URL: Repository, https://github.com/lukleh/mcp-read-only-sql
@@ -30,6 +30,7 @@ Requires-Dist: pytest-timeout>=2.2.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Requires-Dist: ty>=0.0.28; extra == 'dev'
+Requires-Dist: vulture>=2.16; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # MCP Read-Only SQL Server
@@ -85,6 +86,8 @@ See [READ_ONLY_ENFORCEMENT_MATRIX.md](READ_ONLY_ENFORCEMENT_MATRIX.md) for a sta
 
 Install the optional CLI binaries with your operating system's package manager or the official PostgreSQL / ClickHouse packages for your environment.
 
+The CLI binaries are located via the override environment variable (`MCP_READ_ONLY_SQL_PSQL_PATH` / `MCP_READ_ONLY_SQL_CLICKHOUSE_CLIENT_PATH`) if set, then `PATH`, then OS-specific fallback locations (e.g. Homebrew keg-only `libpq` on macOS, packaged PostgreSQL directories on Linux). If a binary is installed somewhere not on `PATH`, set the matching variable to its full path.
+
 The SQL package keeps both execution models first-class:
 
 - `implementation: cli` uses the official database client binaries you already trust in operations.

{mcp_read_only_sql-0.2.2 → mcp_read_only_sql-0.2.6}/README.md

@@ -51,6 +51,8 @@ See [READ_ONLY_ENFORCEMENT_MATRIX.md](READ_ONLY_ENFORCEMENT_MATRIX.md) for a sta
 
 Install the optional CLI binaries with your operating system's package manager or the official PostgreSQL / ClickHouse packages for your environment.
 
+The CLI binaries are located via the override environment variable (`MCP_READ_ONLY_SQL_PSQL_PATH` / `MCP_READ_ONLY_SQL_CLICKHOUSE_CLIENT_PATH`) if set, then `PATH`, then OS-specific fallback locations (e.g. Homebrew keg-only `libpq` on macOS, packaged PostgreSQL directories on Linux). If a binary is installed somewhere not on `PATH`, set the matching variable to its full path.
+
 The SQL package keeps both execution models first-class:
 
 - `implementation: cli` uses the official database client binaries you already trust in operations.

{mcp_read_only_sql-0.2.2 → mcp_read_only_sql-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcp-read-only-sql"
-version = "0.2.2"
+version = "0.2.6"
 description = "MCP server for read-only SQL queries supporting PostgreSQL and ClickHouse"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -40,6 +40,7 @@ dev = [
     "black>=23.0.0",
     "ruff>=0.1.0",
     "ty>=0.0.28",
+    "vulture>=2.16",
 ]
 
 [build-system]
@@ -54,3 +55,10 @@ packages = ["src/mcp_read_only_sql"]
 
 [tool.ty.src]
 include = ["src"]
+
+[tool.vulture]
+paths = ["src", "tests"]
+exclude = [".venv", "venv", "build", "dist", "node_modules", "__pycache__", "site-packages"]
+ignore_decorators = ["@*.tool*", "@pytest.fixture"]
+ignore_names = ["pytest_*"]
+min_confidence = 80

mcp_read_only_sql-0.2.6/src/mcp_read_only_sql/cli_binaries.py

@@ -0,0 +1,158 @@
+"""Resolution of external CLI client binaries (psql, clickhouse-client).
+
+The CLI connectors shell out to a database client. Relying on a bare command
+name only works when the client happens to be on ``PATH``; a common failure is
+macOS Homebrew, where ``psql`` ships with the keg-only ``libpq`` formula and is
+not symlinked onto the default ``PATH`` (the server then fails with
+"psql: command not found").
+
+``resolve_cli_binary`` locates the client without hardcoding install locations
+as the primary mechanism. Resolution order:
+
+1. Explicit override via ``MCP_READ_ONLY_SQL_<BINARY>_PATH`` (matches the
+   project's existing ``MCP_READ_ONLY_SQL_*`` env convention).
+2. :func:`shutil.which` -- honors ``PATH`` (the normal case on Linux and any
+   correctly configured environment).
+3. OS-aware fallback directories, queried dynamically where possible:
+   - macOS: ask Homebrew (``brew --prefix``) where keg-only ``libpq`` / the
+     ``postgresql`` formulae live, plus the standard Homebrew opt dirs.
+   - Linux: standard packaged PostgreSQL layouts (Debian/Ubuntu, PGDG/RHEL).
+
+If every step fails, a :class:`FileNotFoundError` is raised naming the override
+env var so the user can point at the binary explicitly.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+import shutil
+import subprocess
+import sys
+
+from .runtime_paths import ENV_PREFIX
+
+# Upper bound on the optional `brew --prefix` probe so a misbehaving brew can
+# never hang query execution.
+_BREW_PROBE_TIMEOUT = 5  # seconds
+
+# Homebrew formulae that provide each client, in preference order.
+_BREW_FORMULAE: dict[str, list[str]] = {
+    "psql": ["libpq", "postgresql@18", "postgresql@17", "postgresql@16", "postgresql"],
+    "clickhouse-client": ["clickhouse"],
+}
+
+
+def env_var_for(binary: str) -> str:
+    """Return the override env var name for ``binary``.
+
+    ``psql`` -> ``MCP_READ_ONLY_SQL_PSQL_PATH``;
+    ``clickhouse-client`` -> ``MCP_READ_ONLY_SQL_CLICKHOUSE_CLIENT_PATH``.
+    """
+    slug = binary.upper().replace("-", "_")
+    return f"{ENV_PREFIX}_{slug}_PATH"
+
+
+def _is_executable(path: str) -> bool:
+    return bool(path) and os.path.isfile(path) and os.access(path, os.X_OK)
+
+
+def _brew_prefix(formula: str) -> str | None:
+    """Return the Homebrew prefix for ``formula``, or ``None`` if unavailable.
+
+    Note: this uses a blocking ``subprocess.run``. ``resolve_cli_binary`` is
+    synchronous but is called from within the connectors' async ``_run_query``,
+    so this probe blocks the event loop for its duration (bounded by
+    ``_BREW_PROBE_TIMEOUT`` per call). It only runs on the fallback path (binary
+    not pinned and not on PATH, macOS only) and ``BaseCLIConnector`` caches the
+    resolved path per connector, so in practice it runs at most once per
+    connector rather than per query. If that ever becomes a problem (e.g. many
+    connectors resolving concurrently), move the call onto a thread via
+    ``asyncio.to_thread`` or lower ``_BREW_PROBE_TIMEOUT``.
+    """
+    brew = shutil.which("brew")
+    if not brew:
+        return None
+    try:
+        result = subprocess.run(
+            [brew, "--prefix", formula],
+            capture_output=True,
+            text=True,
+            timeout=_BREW_PROBE_TIMEOUT,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return None
+    prefix = result.stdout.strip()
+    return prefix or None
+
+
+def _candidate_dirs(binary: str) -> list[str]:
+    """OS-aware fallback directories to search for ``binary``.
+
+    Evaluated only when the binary is neither pinned via env var nor found on
+    ``PATH``. Homebrew prefixes are resolved dynamically; the static entries are
+    last-resort best effort.
+    """
+    dirs: list[str] = []
+
+    if sys.platform == "darwin":
+        for formula in _BREW_FORMULAE.get(binary, []):
+            prefix = _brew_prefix(formula)
+            if prefix:
+                dirs.append(os.path.join(prefix, "bin"))
+        if binary == "psql":
+            # Standard Homebrew keg-only libpq locations (Apple Silicon, Intel).
+            dirs += ["/opt/homebrew/opt/libpq/bin", "/usr/local/opt/libpq/bin"]
+    elif sys.platform.startswith("linux"):
+        if binary == "psql":
+            # Debian/Ubuntu (postgresql-client-NN) and PGDG/RHEL layouts;
+            # newest version dir first. clickhouse-client has no equivalent
+            # fallback: its distro package installs onto PATH, so which() above
+            # already covers it.
+            dirs += sorted(glob.glob("/usr/lib/postgresql/*/bin"), reverse=True)
+            dirs += sorted(glob.glob("/usr/pgsql-*/bin"), reverse=True)
+
+    return dirs
+
+
+def resolve_cli_binary(binary: str) -> str:
+    """Resolve the absolute path to a CLI client binary.
+
+    Args:
+        binary: The client command name, e.g. ``"psql"`` or
+            ``"clickhouse-client"``.
+
+    Returns:
+        Absolute path to an executable.
+
+    Raises:
+        FileNotFoundError: If the binary cannot be located. The message names
+            the override env var.
+    """
+    env_var = env_var_for(binary)
+
+    override = os.environ.get(env_var)
+    if override:
+        expanded = os.path.expanduser(override)
+        if _is_executable(expanded):
+            return expanded
+        raise FileNotFoundError(
+            f"{binary}: {env_var} is set to '{override}', but that is not an "
+            f"executable file."
+        )
+
+    found = shutil.which(binary)
+    if found:
+        return found
+
+    for directory in _candidate_dirs(binary):
+        candidate = os.path.join(directory, binary)
+        if _is_executable(candidate):
+            return candidate
+
+    raise FileNotFoundError(
+        f"{binary}: command not found. Install the client tools, add them to "
+        f"PATH, or set {env_var} to the full path of the {binary} executable."
+    )

mcp_read_only_sql-0.2.6/src/mcp_read_only_sql/config/__init__.py

@@ -0,0 +1,14 @@
+"""
+Configuration module for connection management
+"""
+
+from .connection import Connection, Server, SSHTunnelConfig
+from .loader import load_connections, load_connections_from_text
+
+__all__ = [
+    "Connection",
+    "Server",
+    "SSHTunnelConfig",
+    "load_connections",
+    "load_connections_from_text",
+]

{mcp_read_only_sql-0.2.2 → mcp_read_only_sql-0.2.6}/src/mcp_read_only_sql/config/loader.py

@@ -8,29 +8,13 @@ import yaml
 from .connection import Connection
 
 
-def load_connections(yaml_path: str | Path) -> Dict[str, Connection]:
-    """
-    Load and validate all connections from YAML configuration file.
-
-    Args:
-        yaml_path: Path to connections.yaml file
-
-    Returns:
-        Dictionary mapping connection name to Connection object
-
-    Raises:
-        FileNotFoundError: If YAML file doesn't exist
-        ValueError: If configuration is invalid (includes all validation errors)
-    """
-    yaml_file = Path(yaml_path).expanduser()
-    if not yaml_file.exists():
-        raise FileNotFoundError(f"Configuration file not found: {yaml_path}")
-
-    with open(yaml_file, encoding="utf-8") as f:
-        raw_configs = yaml.safe_load(f)
-
+def _build_connections_from_raw_configs(
+    raw_configs: Any, source: str | Path
+) -> Dict[str, Connection]:
+    """Validate parsed YAML data and return Connection objects."""
+    source_name = str(source)
     if not raw_configs:
-        raise ValueError(f"Configuration file is empty: {yaml_path}")
+        raise ValueError(f"Configuration file is empty: {source_name}")
 
     if not isinstance(raw_configs, list):
         raise ValueError("Configuration file must contain a list of connections")
@@ -64,3 +48,41 @@ def load_connections(yaml_path: str | Path) -> Dict[str, Connection]:
         raise ValueError(error_msg)
 
     return connections
+
+
+def load_connections_from_text(
+    yaml_text: str, source: str | Path = "<memory>"
+) -> Dict[str, Connection]:
+    """
+    Load and validate connections from a YAML text snapshot.
+
+    Args:
+        yaml_text: Raw YAML document content
+        source: Source label used in validation errors
+    """
+    raw_configs = yaml.safe_load(yaml_text)
+    return _build_connections_from_raw_configs(raw_configs, source)
+
+
+def load_connections(yaml_path: str | Path) -> Dict[str, Connection]:
+    """
+    Load and validate all connections from YAML configuration file.
+
+    Args:
+        yaml_path: Path to connections.yaml file
+
+    Returns:
+        Dictionary mapping connection name to Connection object
+
+    Raises:
+        FileNotFoundError: If YAML file doesn't exist
+        ValueError: If configuration is invalid (includes all validation errors)
+    """
+    yaml_file = Path(yaml_path).expanduser()
+    if not yaml_file.exists():
+        raise FileNotFoundError(f"Configuration file not found: {yaml_path}")
+
+    with open(yaml_file, encoding="utf-8") as f:
+        yaml_text = f.read()
+
+    return load_connections_from_text(yaml_text, yaml_file)

{mcp_read_only_sql-0.2.2 → mcp_read_only_sql-0.2.6}/src/mcp_read_only_sql/connectors/base_cli.py

@@ -8,6 +8,7 @@ import logging
 
 from .base import BaseConnector
 from ..config import Connection
+from ..cli_binaries import resolve_cli_binary
 from ..utils.ssh_tunnel_cli import CLISSHTunnel
 
 logger = logging.getLogger(__name__)
@@ -19,6 +20,26 @@ class BaseCLIConnector(BaseConnector):
     def __init__(self, connection: Connection):
         super().__init__(connection)
         self._ssh_tunnel = None
+        # Resolved CLI client paths, cached per connector instance. Connectors
+        # are rebuilt on config reload, so this re-resolves after a reload while
+        # avoiding a lookup (and a possible `brew --prefix` probe) per query.
+        self._binary_cache: dict[str, str] = {}
+
+    def _resolve_binary(self, name: str) -> str:
+        """Resolve and cache the absolute path to a CLI client binary.
+
+        Called synchronously from the async ``_run_query``. On the macOS
+        fallback path resolution may run a blocking ``brew --prefix`` probe (see
+        ``cli_binaries._brew_prefix``); caching the result here keeps that to at
+        most once per connector instead of once per query. Failures are not
+        cached, so resolution retries on the next query (e.g. if the client is
+        installed mid-session).
+        """
+        cached = self._binary_cache.get(name)
+        if cached is None:
+            cached = resolve_cli_binary(name)
+            self._binary_cache[name] = cached
+        return cached
 
     @asynccontextmanager
     async def _get_ssh_tunnel(self, server: Optional[str] = None):

{mcp_read_only_sql-0.2.2 → mcp_read_only_sql-0.2.6}/src/mcp_read_only_sql/connectors/clickhouse/cli.py

@@ -110,9 +110,11 @@ class ClickHouseCLIConnector(BaseCLIConnector):
             # Use specified database or configured database (validated)
             db_name = self._resolve_database(database)
 
-            # Build clickhouse-client command with read-only enforcement
+            # Build clickhouse-client command with read-only enforcement.
+            # Resolve the client binary explicitly so installs that are not on
+            # PATH still work (mirrors the psql connector).
             cmd = [
-                "clickhouse-client",
+                self._resolve_binary("clickhouse-client"),
                 "--host",
                 host,
                 "--port",

{mcp_read_only_sql-0.2.2 → mcp_read_only_sql-0.2.6}/src/mcp_read_only_sql/connectors/postgresql/cli.py

@@ -75,9 +75,11 @@ class PostgreSQLCLIConnector(BaseCLIConnector):
                 COMMIT;
             """
 
-            # Build psql command with individual parameters
+            # Build psql command with individual parameters.
+            # Resolve the client binary explicitly so installs that are not on
+            # PATH (e.g. Homebrew keg-only libpq on macOS) still work.
             cmd = [
-                "psql",
+                self._resolve_binary("psql"),
                 "--single-transaction",
                 "-v",
                 "ON_ERROR_STOP=1",

{mcp_read_only_sql-0.2.2 → mcp_read_only_sql-0.2.6}/src/mcp_read_only_sql/server.py

@@ -14,13 +14,13 @@ import re
 import sys
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Callable, Dict, List, Optional
+from typing import Callable, Dict, List, Optional, TypeAlias
 from uuid import uuid4
 
 from mcp.server.fastmcp import FastMCP
 
 from . import __version__
-from .config import dbeaver_import, load_connections
+from .config import Connection, dbeaver_import, load_connections_from_text
 from .config.connection import (
     DEFAULT_CONNECTION_TIMEOUT,
     DEFAULT_QUERY_TIMEOUT,
@@ -42,6 +42,7 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 RESULT_FILE_NAME_RE = re.compile(r"[^A-Za-z0-9._-]+")
 RESULT_DIR_HASH_BYTES = 6
+ConfigMarker: TypeAlias = tuple[int, int] | None
 SAMPLE_CONNECTIONS_YAML = (
     files("mcp_read_only_sql")
     .joinpath("connections.yaml.sample")
@@ -81,6 +82,7 @@ class ReadOnlySQLServer:
     def __init__(self, runtime_paths: RuntimePaths):
         self.runtime_paths = runtime_paths
         self.connections: Dict[str, BaseConnector] = {}
+        self._connections_config_marker: ConfigMarker = None
 
         self.runtime_paths.ensure_directories()
         self.mcp = FastMCP("mcp-read-only-sql")
@@ -120,53 +122,103 @@ class ReadOnlySQLServer:
         raise FileExistsError("Could not allocate a unique managed result file")
 
     def _load_connections(self) -> None:
+        """Load connections during startup and remember the current config marker."""
         try:
-            connections_config = load_connections(self.runtime_paths.connections_file)
-
-            errors = []
-
-            for conn_name, connection in connections_config.items():
-                try:
-                    if connection.db_type == "postgresql":
-                        if connection.implementation == "cli":
-                            self.connections[conn_name] = PostgreSQLCLIConnector(
-                                connection
-                            )
-                        else:
-                            self.connections[conn_name] = PostgreSQLPythonConnector(
-                                connection
-                            )
-                    elif connection.db_type == "clickhouse":
-                        if connection.implementation == "cli":
-                            self.connections[conn_name] = ClickHouseCLIConnector(
-                                connection
-                            )
-                        else:
-                            self.connections[conn_name] = ClickHousePythonConnector(
-                                connection
-                            )
-
-                    logger.info(
-                        "Loaded connection: %s (%s, %s)",
-                        conn_name,
-                        connection.db_type,
-                        connection.implementation,
-                    )
-
-                except ImportError as exc:
-                    errors.append(f"  - {conn_name}: Missing dependency - {exc}")
-                except Exception as exc:
-                    errors.append(f"  - {conn_name}: {exc}")
-
-            if errors:
-                error_msg = "Failed to load some connections:\n" + "\n".join(errors)
-                logger.error(error_msg)
-                raise RuntimeError(error_msg)
-
+            self.connections, self._connections_config_marker = self._build_connections()
         except Exception as exc:
             logger.error("Failed to load connections: %s", exc)
             raise
 
+    def _read_connections_config_marker(self) -> ConfigMarker:
+        """Return a lightweight marker for the current connections.yaml state."""
+        try:
+            stat_result = self.runtime_paths.connections_file.stat()
+        except FileNotFoundError:
+            return None
+        return (stat_result.st_mtime_ns, stat_result.st_size)
+
+    def _build_connector(self, connection: Connection) -> BaseConnector:
+        """Create the correct connector implementation for a validated connection."""
+        if connection.db_type == "postgresql":
+            if connection.implementation == "cli":
+                return PostgreSQLCLIConnector(connection)
+            return PostgreSQLPythonConnector(connection)
+        if connection.db_type == "clickhouse":
+            if connection.implementation == "cli":
+                return ClickHouseCLIConnector(connection)
+            return ClickHousePythonConnector(connection)
+        raise ValueError(f"Unsupported database type: {connection.db_type}")
+
+    def _read_connections_config_snapshot(self) -> tuple[str, ConfigMarker]:
+        """Read connections.yaml once and return content with its matching marker."""
+        yaml_file = self.runtime_paths.connections_file.expanduser()
+        try:
+            with open(yaml_file, encoding="utf-8") as f:
+                yaml_text = f.read()
+                stat_result = os.fstat(f.fileno())
+        except FileNotFoundError as exc:
+            raise FileNotFoundError(
+                f"Configuration file not found: {self.runtime_paths.connections_file}"
+            ) from exc
+        return yaml_text, (stat_result.st_mtime_ns, stat_result.st_size)
+
+    def _build_connections(self) -> tuple[Dict[str, BaseConnector], ConfigMarker]:
+        """Build a fresh connector map from one config snapshot without mutating state."""
+        yaml_text, marker = self._read_connections_config_snapshot()
+        connections_config = load_connections_from_text(
+            yaml_text, self.runtime_paths.connections_file
+        )
+        built_connections: Dict[str, BaseConnector] = {}
+        errors = []
+
+        for conn_name, connection in connections_config.items():
+            try:
+                built_connections[conn_name] = self._build_connector(connection)
+                logger.info(
+                    "Loaded connection: %s (%s, %s)",
+                    conn_name,
+                    connection.db_type,
+                    connection.implementation,
+                )
+            except ImportError as exc:
+                errors.append(f"  - {conn_name}: Missing dependency - {exc}")
+            except Exception as exc:
+                errors.append(f"  - {conn_name}: {exc}")
+
+        if errors:
+            error_msg = "Failed to load some connections:\n" + "\n".join(errors)
+            logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+        return built_connections, marker
+
+    def _reload_connections_if_needed(self) -> None:
+        """Reload connections.yaml if it changed, preserving the last good config on errors."""
+        previous_marker = self._connections_config_marker
+        current_marker = self._read_connections_config_marker()
+        if current_marker == previous_marker:
+            return
+
+        logger.info("Detected change in %s; reloading connections", self.runtime_paths.connections_file)
+        try:
+            new_connections, new_marker = self._build_connections()
+        except Exception as exc:
+            logger.warning(
+                "Failed to reload connections from %s; keeping %s previously loaded connection(s): %s",
+                self.runtime_paths.connections_file,
+                len(self.connections),
+                exc,
+            )
+            return
+
+        self.connections = new_connections
+        self._connections_config_marker = new_marker
+        logger.info(
+            "Reloaded %s connection(s) from %s",
+            len(self.connections),
+            self.runtime_paths.connections_file,
+        )
+
     def _setup_tools(self) -> None:
         """Setup MCP tools using FastMCP decorators."""
 
@@ -192,6 +244,7 @@ class ReadOnlySQLServer:
                 directory for this server instance. Successful query results
                 are retained there until removed by the operator.
             """
+            self._reload_connections_if_needed()
             if connection_name not in self.connections:
                 raise ValueError(
                     f"Connection '{connection_name}' not found. Available connections: {', '.join(self.connections.keys())}"
@@ -223,6 +276,7 @@ class ReadOnlySQLServer:
                 hosts for each connection, while ``database`` and ``databases``
                 describe the default database and allowed database list.
             """
+            self._reload_connections_if_needed()
             conn_list = []
 
             for conn_name, connector in self.connections.items():