sqlnow-mcp 0.2.0__tar.gz → 0.2.1__tar.gz

{sqlnow_mcp-0.2.0 → sqlnow_mcp-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlnow-mcp
-Version: 0.2.0
+Version: 0.2.1
 Summary: MCP server for DuckDB with interactive table viewer
 Keywords: mcp,duckdb,sql,llm,claude,cursor
 Author: David Raznick

{sqlnow_mcp-0.2.0 → sqlnow_mcp-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlnow-mcp"
-version = "0.2.0"
+version = "0.2.1"
 description = "MCP server for DuckDB with interactive table viewer"
 readme = "README.md"
 license = "MIT"

{sqlnow_mcp-0.2.0 → sqlnow_mcp-0.2.1}/sqlnow_mcp/cli.py

@@ -53,7 +53,7 @@ def _make_session(
 @click.option(
     "--mode",
     type=click.Choice(["local", "publish"], case_sensitive=False),
-    help="Run as MCP server: 'local' (read/write, data directory) or 'publish' (read-only, metadata).",
+    help="Run as MCP server: 'local' (read-only by default, temporary writes via execute_sql) or 'publish' (read-only, metadata).",
 )
 @click.option(
     "--data-dir",

{sqlnow_mcp-0.2.0 → sqlnow_mcp-0.2.1}/sqlnow_mcp/db.py

@@ -6,12 +6,13 @@ import threading
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any, Callable, Literal, TypeVar
 
 import duckdb
 
 AttachMode = Literal["view", "load"]
 DbType = Literal["POSTGRES", "SQLITE", "MYSQL"]
+T = TypeVar("T")
 
 MAX_ROWS = 100_000
 BACKGROUND_CHUNK_ROWS = 2_000
@@ -28,7 +29,7 @@ class DuckDBSession:
         allow_paths: list[Path] | tuple[Path, ...] = (),
         allow_external: bool = False,
         *,
-        read_only: bool = False,
+        read_only: bool = True,
         query_timeout_sec: float | None = None,
     ) -> None:
         self.data_dir = data_dir.resolve()
@@ -63,23 +64,8 @@ class DuckDBSession:
         if not db_path.exists():
             raise DuckDBSessionError(f"Database not found: {db_name}")
 
-        self._close_connection()
-        self.conn = duckdb.connect(str(db_path))
-        self._install_extensions(self.conn)
-        self.active_db = db_path
-        self.attachments = []
-        self.failed_attachments = []
-
-        sidecar = self._load_sidecar(db_path)
-        for entry in sidecar.get("attachments", []):
-            try:
-                if not self._is_attached(entry["name"]):
-                    self._attach_from_sidecar(entry)
-                self.attachments.append(entry)
-            except Exception as exc:
-                failed = dict(entry)
-                failed["error"] = str(exc)
-                self.failed_attachments.append(failed)
+        self._open_database_connection(db_path, read_only=self.read_only)
+        self._load_database_attachments(db_path)
 
         return {
             "name": db_path.stem,
@@ -182,15 +168,19 @@ class DuckDBSession:
         name: str | None = None,
         mode: AttachMode = "view",
     ) -> dict[str, Any]:
-        conn = self._require_conn()
         resolved = self._resolve_allowed_path(path)
         if not resolved.exists():
             raise DuckDBSessionError(f"File not found: {path}")
 
         table_name = name or resolved.stem
         sql = self._file_attach_sql(resolved, table_name, mode)
-        conn.execute(sql)
-        return {"name": table_name, "path": str(resolved), "mode": mode}
+
+        def attach() -> dict[str, Any]:
+            conn = self._require_conn()
+            conn.execute(sql)
+            return {"name": table_name, "path": str(resolved), "mode": mode}
+
+        return self._with_temporary_write_connection(attach)
 
     def attach_database(
         self,
@@ -201,13 +191,11 @@ class DuckDBSession:
         if not self.allow_external:
             raise DuckDBSessionError("External database attachments are disabled")
 
-        conn = self._require_conn()
         db_type, attach_str = self._parse_database_connection(connection_string)
         sql = (
             f"ATTACH '{self._escape_sql_string(attach_str)}' "
             f"AS {self._quote_ident(name)} (TYPE {db_type})"
         )
-        conn.execute(sql)
 
         entry: dict[str, Any] = {
             "name": name,
@@ -217,26 +205,40 @@ class DuckDBSession:
         if tables:
             entry["tables"] = tables
 
-        self.attachments.append(entry)
-        self._save_sidecar()
-        return entry
-
-    def detach_source(self, name: str) -> dict[str, Any]:
-        conn = self._require_conn()
-        attachment = next((a for a in self.attachments if a["name"] == name), None)
-        if attachment is not None:
-            conn.execute(f"DETACH {self._quote_ident(name)}")
-            self.attachments = [a for a in self.attachments if a["name"] != name]
+        def attach() -> dict[str, Any]:
+            conn = self._require_conn()
+            conn.execute(sql)
+            self.attachments.append(entry)
             self._save_sidecar()
-            return {"name": name, "detached": True, "type": "database"}
+            return entry
 
-        quoted = self._quote_ident(name)
-        conn.execute(f"DROP VIEW IF EXISTS {quoted}")
-        conn.execute(f"DROP TABLE IF EXISTS {quoted}")
-        return {"name": name, "detached": True, "type": "file"}
+        return self._with_temporary_write_connection(attach)
+
+    def detach_source(self, name: str) -> dict[str, Any]:
+        def detach() -> dict[str, Any]:
+            conn = self._require_conn()
+            attachment = next((a for a in self.attachments if a["name"] == name), None)
+            if attachment is not None:
+                conn.execute(f"DETACH {self._quote_ident(name)}")
+                self.attachments = [a for a in self.attachments if a["name"] != name]
+                self._save_sidecar()
+                return {"name": name, "detached": True, "type": "database"}
+
+            quoted = self._quote_ident(name)
+            conn.execute(f"DROP VIEW IF EXISTS {quoted}")
+            conn.execute(f"DROP TABLE IF EXISTS {quoted}")
+            return {"name": name, "detached": True, "type": "file"}
+
+        return self._with_temporary_write_connection(detach)
 
     def run_mutating_query(self, sql: str) -> dict[str, Any]:
-        result = self._run_sql(sql.strip().rstrip(";"))
+        stripped = sql.strip().rstrip(";")
+        if self.read_only and self.active_db is not None:
+            return self._with_temporary_write_connection(
+                lambda: self._format_execution_result(self._run_sql(stripped))
+            )
+
+        result = self._run_sql(stripped)
         return self._format_execution_result(result)
 
     def run_query(self, sql: str, limit: int = 500) -> dict[str, Any]:
@@ -510,6 +512,42 @@ class DuckDBSession:
         self._query_view_ids = []
         self._query_meta = {}
 
+    def _open_database_connection(self, db_path: Path, *, read_only: bool) -> None:
+        self._close_connection()
+        self.conn = duckdb.connect(str(db_path), read_only=read_only)
+        self._install_extensions(self.conn)
+        self.active_db = db_path
+        self.attachments = []
+        self.failed_attachments = []
+
+    def _load_database_attachments(self, db_path: Path) -> None:
+        sidecar = self._load_sidecar(db_path)
+        for entry in sidecar.get("attachments", []):
+            try:
+                if not self._is_attached(entry["name"]):
+                    self._attach_from_sidecar(entry)
+                self.attachments.append(entry)
+            except Exception as exc:
+                failed = dict(entry)
+                failed["error"] = str(exc)
+                self.failed_attachments.append(failed)
+
+    def _with_temporary_write_connection(self, operation: Callable[[], T]) -> T:
+        if not self.read_only or self.active_db is None:
+            return operation()
+
+        db_path = self.active_db
+        if db_path is None:
+            raise DuckDBSessionError("No active database connection")
+
+        try:
+            self._open_database_connection(db_path, read_only=False)
+            self._load_database_attachments(db_path)
+            return operation()
+        finally:
+            self._open_database_connection(db_path, read_only=True)
+            self._load_database_attachments(db_path)
+
     @staticmethod
     def _new_query_id() -> str:
         return secrets.token_hex(6)

{sqlnow_mcp-0.2.0 → sqlnow_mcp-0.2.1}/sqlnow_mcp/server.py

@@ -75,7 +75,9 @@ Use only for smallish results — keep ``limit`` low and aggregate in SQL when \
 possible. Large payloads are truncated or rejected; use ``run_query`` for bigger \
 result sets the user should browse.
 
-execute_sql() returns a text summary only (no table viewer).
+Persistent database sessions are opened read-only by default. execute_sql() briefly
+reopens the active database read/write for that statement, then restores the
+read-only connection. execute_sql() returns a text summary only (no table viewer).
 
 Session state persists across tool calls. Call use_database or use_memory first \
 before list_tables, run_query, run_query_json, execute_sql, or other tools that \