sqlbuddy-nwi 0.3.3__tar.gz → 0.4.0__tar.gz

{sqlbuddy_nwi-0.3.3 → sqlbuddy_nwi-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuddy-nwi
-Version: 0.3.3
+Version: 0.4.0
 Summary: MCP server for read-only database access (MySQL, ClickHouse)
 Author: ying.yuxiang
 License: MIT
@@ -23,7 +23,6 @@ License-File: LICENSE
 Requires-Dist: mcp<2,>=1.0.0
 Requires-Dist: pymysql>=1.1.0
 Requires-Dist: clickhouse-driver>=0.2.6
-Requires-Dist: pandas>=2.0.0
 Requires-Dist: platformdirs>=4.0.0
 Dynamic: license-file
 
@@ -67,19 +66,40 @@ SQL Buddy runs **locally** (a small Python program, not a cloud service). It
 
 ## Quickstart
 
+**Install** (current release [![PyPI](https://img.shields.io/pypi/v/sqlbuddy-nwi.svg)](https://pypi.org/project/sqlbuddy-nwi/), Python ≥ 3.11):
+
 ```bash
-git clone <this-repo-url> sql-buddy && cd sql-buddy
-uv run server.py            # installs deps into an isolated .venv, then serves (Ctrl+C to stop)
-uv run sql-buddy init       # interactive wizard → writes connections/config/db.ini
-uv run sql-buddy doctor --connect   # green-checks the venv, db.ini, tunnels, MCP client config
-uv run sql-buddy mcp add    # registers sql-buddy with Claude Code (writes .mcp.json)
+# From PyPI (recommended):
+pip install sqlbuddy-nwi          # provides the `sql-buddy` command
+# …or run the latest instantly without installing:
+uvx --from sqlbuddy-nwi sql-buddy
 ```
 
+```bash
+# From source (for development):
+git clone https://github.com/yyx462/sql-buddy && cd sql-buddy
+uv run server.py                  # auto-provisions an isolated .venv, then serves
+```
+
+**Configure & connect:**
+
+```bash
+sql-buddy init                    # interactive wizard → writes connections/config/db.ini
+sql-buddy doctor --connect        # green-checks db.ini, tunnels, MCP client config
+sql-buddy mcp add                 # registers sql-buddy with Claude Code (writes .mcp.json)
+```
+
+> From a **git checkout**, prefix these with `uv run` (e.g. `uv run sql-buddy init`).
+> From a **pip / uvx install**, run `sql-buddy` directly — it's on your PATH.
+
 Restart your client, then ask your agent *"list the tables in the `ck`
 connection"* — if it answers, you're live. 🎉
 
 > **Bare `sql-buddy` (no command) runs the MCP server** — that's what your AI
 > client invokes, so configs hold no fragile absolute `.venv/bin/python` path.
+> `sql-buddy mcp add` auto-detects how you installed and writes the right
+> command: `uvx --from sqlbuddy-nwi sql-buddy` for a pip/uvx install,
+> `uv --directory … run server.py` for a checkout.
 > Other commands: `version`, `doctor [--connect]`, `mcp print|add`, `update-check`, `init`.
 > On **Windows**, see [`docs/windows-trae.md`](docs/windows-trae.md) and use
 > `sql-buddy mcp add --client trae`.
@@ -91,8 +111,8 @@ connection"* — if it answers, you're live. 🎉
 Run the wizard (easiest) or copy the template:
 
 ```bash
-uv run sql-buddy init
-# or by hand:
+sql-buddy init
+# or, from a git checkout, copy the template and edit by hand:
 cp connections/config/db.ini.example connections/config/db.ini
 $EDITOR connections/config/db.ini
 ```
@@ -140,13 +160,13 @@ reference, SSH troubleshooting, and External (`ssh -N`) mode, see
 ## Connect your AI agent
 
 ```bash
-uv run sql-buddy mcp add                      # Claude Code project → ./.mcp.json
-uv run sql-buddy mcp add --scope user         # Claude Code user    → ~/.claude.json
-uv run sql-buddy mcp add --client trae        # Trae project        → ./.trae/mcp.json
-uv run sql-buddy mcp add --client trae --scope user   # Trae user-global
+sql-buddy mcp add                      # Claude Code project → ./.mcp.json
+sql-buddy mcp add --scope user         # Claude Code user    → ~/.claude.json
+sql-buddy mcp add --client trae        # Trae project        → ./.trae/mcp.json
+sql-buddy mcp add --client trae --scope user   # Trae user-global
 ```
 
-Restart your client. Preview the exact block first with `uv run sql-buddy mcp print`
+Restart your client. Preview the exact block first with `sql-buddy mcp print`
 (paths filled in):
 
 ```json

{sqlbuddy_nwi-0.3.3 → sqlbuddy_nwi-0.4.0}/README.md

@@ -38,19 +38,40 @@ SQL Buddy runs **locally** (a small Python program, not a cloud service). It
 
 ## Quickstart
 
+**Install** (current release [![PyPI](https://img.shields.io/pypi/v/sqlbuddy-nwi.svg)](https://pypi.org/project/sqlbuddy-nwi/), Python ≥ 3.11):
+
 ```bash
-git clone <this-repo-url> sql-buddy && cd sql-buddy
-uv run server.py            # installs deps into an isolated .venv, then serves (Ctrl+C to stop)
-uv run sql-buddy init       # interactive wizard → writes connections/config/db.ini
-uv run sql-buddy doctor --connect   # green-checks the venv, db.ini, tunnels, MCP client config
-uv run sql-buddy mcp add    # registers sql-buddy with Claude Code (writes .mcp.json)
+# From PyPI (recommended):
+pip install sqlbuddy-nwi          # provides the `sql-buddy` command
+# …or run the latest instantly without installing:
+uvx --from sqlbuddy-nwi sql-buddy
 ```
 
+```bash
+# From source (for development):
+git clone https://github.com/yyx462/sql-buddy && cd sql-buddy
+uv run server.py                  # auto-provisions an isolated .venv, then serves
+```
+
+**Configure & connect:**
+
+```bash
+sql-buddy init                    # interactive wizard → writes connections/config/db.ini
+sql-buddy doctor --connect        # green-checks db.ini, tunnels, MCP client config
+sql-buddy mcp add                 # registers sql-buddy with Claude Code (writes .mcp.json)
+```
+
+> From a **git checkout**, prefix these with `uv run` (e.g. `uv run sql-buddy init`).
+> From a **pip / uvx install**, run `sql-buddy` directly — it's on your PATH.
+
 Restart your client, then ask your agent *"list the tables in the `ck`
 connection"* — if it answers, you're live. 🎉
 
 > **Bare `sql-buddy` (no command) runs the MCP server** — that's what your AI
 > client invokes, so configs hold no fragile absolute `.venv/bin/python` path.
+> `sql-buddy mcp add` auto-detects how you installed and writes the right
+> command: `uvx --from sqlbuddy-nwi sql-buddy` for a pip/uvx install,
+> `uv --directory … run server.py` for a checkout.
 > Other commands: `version`, `doctor [--connect]`, `mcp print|add`, `update-check`, `init`.
 > On **Windows**, see [`docs/windows-trae.md`](docs/windows-trae.md) and use
 > `sql-buddy mcp add --client trae`.
@@ -62,8 +83,8 @@ connection"* — if it answers, you're live. 🎉
 Run the wizard (easiest) or copy the template:
 
 ```bash
-uv run sql-buddy init
-# or by hand:
+sql-buddy init
+# or, from a git checkout, copy the template and edit by hand:
 cp connections/config/db.ini.example connections/config/db.ini
 $EDITOR connections/config/db.ini
 ```
@@ -111,13 +132,13 @@ reference, SSH troubleshooting, and External (`ssh -N`) mode, see
 ## Connect your AI agent
 
 ```bash
-uv run sql-buddy mcp add                      # Claude Code project → ./.mcp.json
-uv run sql-buddy mcp add --scope user         # Claude Code user    → ~/.claude.json
-uv run sql-buddy mcp add --client trae        # Trae project        → ./.trae/mcp.json
-uv run sql-buddy mcp add --client trae --scope user   # Trae user-global
+sql-buddy mcp add                      # Claude Code project → ./.mcp.json
+sql-buddy mcp add --scope user         # Claude Code user    → ~/.claude.json
+sql-buddy mcp add --client trae        # Trae project        → ./.trae/mcp.json
+sql-buddy mcp add --client trae --scope user   # Trae user-global
 ```
 
-Restart your client. Preview the exact block first with `uv run sql-buddy mcp print`
+Restart your client. Preview the exact block first with `sql-buddy mcp print`
 (paths filled in):
 
 ```json

{sqlbuddy_nwi-0.3.3 → sqlbuddy_nwi-0.4.0}/_version.py

@@ -7,4 +7,4 @@ still report a version. `cli.get_version()` prefers installed metadata when
 available and falls back to this.
 """
 
-__version__ = "0.3.3"
+__version__ = "0.4.0"

{sqlbuddy_nwi-0.3.3 → sqlbuddy_nwi-0.4.0}/cli.py

@@ -44,7 +44,6 @@ _RUNTIME_DEPS = [
     ("mcp", "mcp.server.fastmcp"),
     ("pymysql", None),
     ("clickhouse_driver", None),
-    ("pandas", None),
     ("platformdirs", None),
 ]
 
@@ -1025,6 +1024,10 @@ sql-buddy {ver}  — read-only MCP database server
 
 Usage:
   sql-buddy [serve|stdio]        run the MCP server over stdio (default)
+  sql-buddy http [--host H] [--port P]
+                                 run ONE shared MCP server over streamable
+                                 HTTP — N agents, one process, one tunnel
+                                 (default 127.0.0.1:7801; see docs/setup.md)
   sql-buddy version              print version
   sql-buddy doctor [--connect]   validate install + db.ini (+ live pings)
   sql-buddy update-check         compare local checkout to the git remote
@@ -1057,10 +1060,32 @@ def _run_server() -> int:
     return 0
 
 
+def _run_http(host: str, port: int) -> int:
+    import server
+    server.run_http(host=host, port=port)
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     args = list(sys.argv[1:] if argv is None else argv)
     if not args or args[0] in ("serve", "server", "stdio"):
         return _run_server()
+    if args[0] == "http":
+        host, port = "127.0.0.1", 7801
+        it = iter(args[1:])
+        for flag in it:
+            if flag == "--host":
+                host = next(it, host)
+            elif flag == "--port":
+                raw = next(it, "")
+                if not raw.isdigit():
+                    print("error: --port needs an integer", file=sys.stderr)
+                    return 2
+                port = int(raw)
+            else:
+                print(f"error: unknown http option '{flag}'", file=sys.stderr)
+                return 2
+        return _run_http(host, port)
 
     cmd, rest = args[0], args[1:]
 

{sqlbuddy_nwi-0.3.3 → sqlbuddy_nwi-0.4.0}/connections/manager.py

@@ -10,7 +10,6 @@ generation bumps (the previous TCP socket is dead after a restart).
 import configparser
 import os
 import sys
-import uuid
 from contextlib import contextmanager
 from typing import Any, Dict, Tuple
 
@@ -29,7 +28,21 @@ from .wrappers import (
 _REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 if _REPO_ROOT not in sys.path:
     sys.path.insert(0, _REPO_ROOT)
-from tunnel import get_manager as _get_tunnel_manager
+
+
+def _get_tunnel_manager():
+    """Return the process-wide TunnelManager (imported lazily).
+
+    A module-level `from tunnel import get_manager` here creates a genuine
+    import cycle: `import tunnel` -> `connections.config_util` ->
+    `connections/__init__` -> manager -> `from tunnel import get_manager`
+    while tunnel is still mid-initialization. tunnel.py's `except ImportError`
+    then silently swallows the collision and its config helpers stay None,
+    breaking every TunnelManager built in that process. Deferring the import
+    to call time breaks the cycle, so `import tunnel` works in any order.
+    """
+    from tunnel import get_manager
+    return get_manager()
 
 
 DEFAULT_REMOTE_DB_CREDS: Dict[str, Tuple[str, str]] = {}
@@ -135,10 +148,27 @@ class DBManager:
         return conn_config
 
     def _create_clickhouse_client(self, section: str) -> Client:
-        return Client(**self._resolve_conn_config(section, 9000))
+        cfg = self._resolve_conn_config(section, 9000)
+        # Default timeouts: a black-holed endpoint (dead tunnel forward, silent
+        # DB) must raise instead of parking the caller's worker thread in a
+        # socket read forever. Explicit keys in the db.ini section win.
+        cfg.setdefault('connect_timeout', 10)
+        cfg.setdefault('send_receive_timeout', 900)
+        for k in ('connect_timeout', 'send_receive_timeout'):
+            cfg[k] = int(cfg[k])  # ini values arrive as strings; drivers want ints
+        return Client(**cfg)
 
     def _create_mysql_client(self, section: str) -> MySQLConnectionWrapper:
-        return MySQLConnectionWrapper(pymysql.connect(**self._resolve_conn_config(section, 3306)))
+        cfg = self._resolve_conn_config(section, 3306)
+        # Same bounds for MySQL; read/write must exceed the 600s
+        # innodb_lock_wait_timeout the locked wrapper sets, so legit
+        # lock-waits are not cut short.
+        cfg.setdefault('connect_timeout', 10)
+        cfg.setdefault('read_timeout', 900)
+        cfg.setdefault('write_timeout', 900)
+        for k in ('connect_timeout', 'read_timeout', 'write_timeout'):
+            cfg[k] = int(cfg[k])  # ini values arrive as strings; drivers want ints
+        return MySQLConnectionWrapper(pymysql.connect(**cfg))
 
     def all_clients(self) -> Dict[str, Any]:
         return {name: entry['client'] for name, entry in self._cache.items()}
@@ -151,35 +181,6 @@ class DBManager:
             elif hasattr(client, "close"):
                 client.close()
 
-    @contextmanager
-    def session_scope(self, client_name: str = 'ck'):
-        client = getattr(self, client_name)
-        session_id = str(uuid.uuid4())
-        original_execute = client.execute
-        original_query_dataframe = getattr(client, 'query_dataframe', None)
-
-        def scoped_execute(query, params=None, settings=None, **kwargs):
-            if settings is None:
-                settings = {}
-            settings['session_id'] = session_id
-            return original_execute(query, params=params, settings=settings, **kwargs)
-
-        def scoped_query_dataframe(query, params=None, settings=None, **kwargs):
-            if settings is None:
-                settings = {}
-            settings['session_id'] = session_id
-            return original_query_dataframe(query, params=params, settings=settings, **kwargs)
-
-        class SessionClient:
-            def execute(self, *args, **kwargs):
-                return scoped_execute(*args, **kwargs)
-            def query_dataframe(self, *args, **kwargs):
-                if original_query_dataframe:
-                    return scoped_query_dataframe(*args, **kwargs)
-                raise AttributeError("query_dataframe not available on this client")
-
-        yield SessionClient()
-
     @contextmanager
     def transaction_scope(self, connection: str):
         conn = getattr(self, connection)

{sqlbuddy_nwi-0.3.3 → sqlbuddy_nwi-0.4.0}/connections/wrappers.py

@@ -10,7 +10,6 @@ See UBIQUITOUS_LANGUAGE.md: "Locked" == the wrapper layer enforcing Read-only.
 
 import pymysql
 from clickhouse_driver import Client
-import pandas as pd
 
 from .readonly import _filter_sql
 
@@ -31,12 +30,19 @@ class MySQLConnectionWrapper:
         finally:
             cursor.close()
 
-    def query_dataframe(self, sql: str) -> pd.DataFrame:
+    def query_rows(self, sql: str):
+        """Read `sql` and return (column_names, rows_as_dicts).
+
+        Replaces the old `query_dataframe` (which wrapped these same rows in a
+        pandas DataFrame — a 45 MiB import per process). Same DictCursor
+        semantics, plain dicts out.
+        """
         cursor = self._conn.cursor(pymysql.cursors.DictCursor)
         try:
             cursor.execute(sql)
             rows = cursor.fetchall()
-            return pd.DataFrame(rows)
+            columns = [d[0] for d in cursor.description] if cursor.description else []
+            return columns, list(rows)
         finally:
             cursor.close()
 
@@ -68,9 +74,9 @@ class LockedMySQLConnectionWrapper:
         _filter_sql(sql)
         return self._wrapped.db_execute(sql, params)
 
-    def query_dataframe(self, sql: str) -> pd.DataFrame:
+    def query_rows(self, sql: str):
         _filter_sql(sql)
-        return self._wrapped.query_dataframe(sql)
+        return self._wrapped.query_rows(sql)
 
 
 class LockedClickHouseClient:
@@ -88,15 +94,6 @@ class LockedClickHouseClient:
             settings=settings, **kwargs
         )
 
-    def query_dataframe(self, query, params=None, settings=None, **kwargs):
-        _filter_sql(query)
-        result = self._wrapped.execute(query, params=params, settings=settings, with_column_types=True, **kwargs)
-        if result:
-            data, columns = result
-            if data:
-                return pd.DataFrame(data, columns=[c[0] for c in columns])
-        return pd.DataFrame()
-
     def disconnect(self):
         return self._wrapped.disconnect()
 

{sqlbuddy_nwi-0.3.3 → sqlbuddy_nwi-0.4.0}/db_query.py

@@ -135,31 +135,33 @@ def _is_query_allowed(sql: str) -> bool:
     return any(sql_trimmed.startswith(p) for p in allowed)
 
 
+def _fetch_rows(client, sql: str):
+    """Dialect-agnostic read path: -> (column_names, rows_as_dicts). No pandas.
+
+    MySQL wrapper (raw or Locked) exposes `query_rows`; ClickHouse goes through
+    `execute(with_column_types=True)` (the Locked client filters it first).
+    Replaces the old `hasattr(client, 'query_dataframe')` DataFrame dispatch:
+    same output shape, none of the 45 MiB pandas import.
+    """
+    if hasattr(client, 'query_rows'):
+        return client.query_rows(sql)
+    result = client.execute(sql, with_column_types=True)
+    if not result or not result[0]:
+        return [], []
+    data, columns = result
+    col_names = [c[0] for c in columns]
+    return col_names, [dict(zip(col_names, row)) for row in data]
+
+
 def _result_to_json(client, sql: str) -> str:
     """Execute SQL and return JSON string with columns + rows. Decimals cast to float."""
-    if hasattr(client, 'query_dataframe'):
-        df = client.query_dataframe(sql)
-        if df.empty:
-            return json.dumps({"columns": [], "rows": [], "row_count": 0})
-        rows = [_sanitize_row(r) for r in df.to_dict(orient='records')]
-        return json.dumps({
-            "columns": list(df.columns),
-            "rows": rows,
-            "row_count": len(rows),
-        }, default=str)
-    else:
-        # ClickHouse
-        result = client.execute(sql, with_column_types=True)
-        if not result or not result[0]:
-            return json.dumps({"columns": [], "rows": [], "row_count": 0})
-        data, columns = result
-        col_names = [c[0] for c in columns]
-        rows = [_sanitize_row(dict(zip(col_names, row))) for row in data]
-        return json.dumps({
-            "columns": col_names,
-            "rows": rows,
-            "row_count": len(rows),
-        }, default=str)
+    columns, rows = _fetch_rows(client, sql)
+    rows = [_sanitize_row(r) for r in rows]
+    return json.dumps({
+        "columns": columns,
+        "rows": rows,
+        "row_count": len(rows),
+    }, default=str)
 
 
 # --- Schema ---
@@ -287,12 +289,10 @@ def table_schema_query(tbl_name: str, connection: str = 'ck', force_refresh: boo
         db = DBManager()
         client = getattr(db, connection)
 
-        if hasattr(client, 'query_dataframe'):
-            result = client.query_dataframe(f"SHOW CREATE TABLE {tbl_name}")
-            schema = result.to_string() if not result.empty else ""
-        else:
-            result = client.execute(f"SHOW CREATE TABLE {tbl_name}")
-            schema = str(result[0][0]) if result else ""
+        # MySQL: (Table, Create Table) — the DDL is the LAST column;
+        # ClickHouse: a single `statement` column. columns[-1] serves both.
+        columns, rows = _fetch_rows(client, f"SHOW CREATE TABLE {tbl_name}")
+        schema = str(rows[0][columns[-1]]) if rows and columns else ""
 
         schema = schema.strip().replace('statement\n', '').strip()
         if schema and schema[0].isdigit():
@@ -323,12 +323,13 @@ def table_schema_query(tbl_name: str, connection: str = 'ck', force_refresh: boo
 def _resolve_connection_type(connection: str) -> str:
     """Resolve a connection name to its DBMS type ('clickhouse' | 'mysql').
 
-    Replaces the brittle ``hasattr(client, 'query_dataframe')`` dispatch: BOTH
-    Locked wrappers define ``query_dataframe`` (MySQL natively, ClickHouse via
-    the adapter in connections/wrappers.py), so that attribute check *always*
-    picked the MySQL branch — even for ClickHouse, which then fabricated a
-    fake PRIMARY index from ClickHouse's stub ``SHOW INDEX``. This reads the
-    section's declared ``type`` (with the section-name prefix fallback), the
+    Replaces the brittle ``hasattr(client, 'query_dataframe')`` dialect
+    dispatch of the old pandas era: BOTH Locked wrappers defined it (MySQL
+    natively, ClickHouse via an adapter), so the check *always* picked the
+    MySQL branch -- even for ClickHouse, which then fabricated a fake PRIMARY
+    index from ClickHouse's stub ``SHOW INDEX``. The pandas-free `query_rows`
+    interface is MySQL-only again, but dialect is still read from the
+    section's declared `type` (with the section-name prefix fallback), the
     same source of truth ``find_table_query`` uses. Connection names use
     underscores; db.ini sections use dashes, so normalize the way
     DBManager.__getattr__ does.
@@ -411,14 +412,14 @@ def table_info_query(tbl_name: str, connection: str = 'ck', force_refresh: bool
         if ctype == 'mysql':
             # MySQL: SHOW INDEX returns real BTREE indexes with real cardinality.
             try:
-                result = client.query_dataframe(f"SELECT COUNT(*) as cnt FROM {tbl_name}")
-                info['row_count'] = int(result['cnt'].iloc[0]) if not result.empty else 0
+                _cols, rows = _fetch_rows(client, f"SELECT COUNT(*) as cnt FROM {tbl_name}")
+                info['row_count'] = int(rows[0]['cnt']) if rows else 0
             except Exception:
                 info['row_count'] = None
             try:
-                idx_result = client.query_dataframe(f"SHOW INDEX FROM {tbl_name}")
-                if not idx_result.empty:
-                    info['indexes'] = idx_result.to_dict('records')
+                _cols, rows = _fetch_rows(client, f"SHOW INDEX FROM {tbl_name}")
+                if rows:
+                    info['indexes'] = rows
             except Exception:
                 info['indexes'] = []
         else:
@@ -501,10 +502,7 @@ def check_connection_query(connection: str = 'ck') -> str:
     start = time.time()
     db = DBManager()
     client = getattr(db, connection)  # raises AttributeError if unknown; starts tunnel if Auto
-    if hasattr(client, 'query_dataframe'):
-        client.query_dataframe('SELECT 1')
-    else:
-        client.execute('SELECT 1')
+    _fetch_rows(client, 'SELECT 1')
     return json.dumps({
         "connection": connection,
         "status": "ok",
@@ -518,18 +516,18 @@ def list_tables(connection: str = 'ck', database: str | None = None, like: str |
         db = DBManager()
         client = getattr(db, connection)
 
-        if hasattr(client, 'query_dataframe'):
+        if hasattr(client, 'query_rows'):
             # MySQL
             sql = "SHOW TABLES"
             if database:
                 sql = f"SHOW TABLES FROM `{database}`"
             if like:
                 sql += f" LIKE '{like}'"
-            result = client.query_dataframe(sql)
-            if result.empty:
+            columns, rows = _fetch_rows(client, sql)
+            if not rows:
                 return json.dumps({"tables": [], "count": 0})
-            col = result.columns[0]
-            tables = result[col].tolist()
+            first = columns[0] if columns else ''
+            tables = [str(r.get(first)) for r in rows]
         else:
             # ClickHouse
             if database:
@@ -614,17 +612,16 @@ def _full_catalog_query(ctype: str) -> str:
 
 def _exec_catalog(client, sql: str) -> list:
     """Run a catalog SELECT; return list of (database, table, engine) tuples."""
-    if hasattr(client, 'query_dataframe'):
-        df = client.query_dataframe(sql)
-        if df is None or getattr(df, 'empty', True):
-            return []
-        out = []
-        for row in df.itertuples(index=False, name=None):
-            db_name = str(row[0]) if len(row) > 0 and row[0] is not None else ''
-            tbl = str(row[1]) if len(row) > 1 and row[1] is not None else ''
-            eng = str(row[2]) if len(row) > 2 and row[2] is not None else ''
-            out.append((db_name, tbl, eng))
-        return out
+    if hasattr(client, 'query_rows'):
+        _cols, rows = _fetch_rows(client, sql)
+        return [
+            (
+                str(r.get('db_name')) if r.get('db_name') is not None else '',
+                str(r.get('tbl_name')) if r.get('tbl_name') is not None else '',
+                str(r.get('engine')) if r.get('engine') is not None else '',
+            )
+            for r in rows
+        ]
     result = client.execute(sql, with_column_types=True)
     if not result or not result[0]:
         return []
@@ -757,12 +754,9 @@ def explain_query(sql: str, connection: str = 'ck') -> str:
         db = DBManager()
         client = getattr(db, connection)
 
-        if hasattr(client, 'query_dataframe'):
-            result = client.query_dataframe(explain_sql)
-            if result.empty:
-                return json.dumps({"plan": [], "raw": ""})
-            col = result.columns[0]
-            plan_lines = result[col].tolist()
+        if hasattr(client, 'query_rows'):
+            columns, rows = _fetch_rows(client, explain_sql)
+            plan_lines = [row[columns[0]] for row in rows] if rows and columns else []
         else:
             result = client.execute(explain_sql)
             plan_lines = [row[0] for row in result] if result else []

{sqlbuddy_nwi-0.3.3 → sqlbuddy_nwi-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlbuddy-nwi"
-version = "0.3.3"
+version = "0.4.0"
 description = "MCP server for read-only database access (MySQL, ClickHouse)"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -25,7 +25,6 @@ dependencies = [
     "mcp>=1.0.0,<2",
     "pymysql>=1.1.0",
     "clickhouse-driver>=0.2.6",
-    "pandas>=2.0.0",
     "platformdirs>=4.0.0",
 ]
 
@@ -54,3 +53,9 @@ packages = ["connections"]
 [project.scripts]
 sql-buddy = "cli:main"
 sql-buddy-init = "init:main"
+
+# Only `tests/` holds pytest tests. Without this, bare `pytest` also collects
+# the root-level test_vendor.py script, whose import-time sys.exit(1) crashes
+# the whole run with an INTERNALERROR.
+[tool.pytest.ini_options]
+testpaths = ["tests"]

{sqlbuddy_nwi-0.3.3 → sqlbuddy_nwi-0.4.0}/server.py

@@ -263,6 +263,25 @@ def run_server():
     mcp.run(transport="stdio")
 
 
+def run_http(host: str = "127.0.0.1", port: int = 7801):
+    """Run ONE shared MCP server over streamable HTTP (`sql-buddy http`).
+
+    Every agent connects to http://host:port/mcp — one process, one ssh
+    tunnel, one set of local forward ports, so concurrent agents can never
+    collide on tunnel port binds the way N stdio processes do. Requests are
+    independent: each tool call builds its own DBManager/client (db_query),
+    so there is no shared-connection state between agents.
+
+    Trade-off vs stdio: shared fate. If this process dies, every agent loses
+    DB access until it restarts — run it under a supervisor (systemd --user
+    with Restart=always; see docs/setup.md). Binds localhost by default;
+    do not expose it to a network without an auth layer in front.
+    """
+    mcp.settings.host = host
+    mcp.settings.port = port
+    mcp.run(transport="streamable-http")
+
+
 if __name__ == "__main__":
     # Bare `python server.py` (or `python server.py serve`) starts the MCP
     # server — the common case for MCP client configs. Any other subcommand