sqlsaber 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

sqlsaber/cli/database.py

@@ -40,6 +40,20 @@ def add_database(
         None, "--database", "--db", help="Database name"
     ),
     username: Optional[str] = typer.Option(None, "--username", "-u", help="Username"),
+    ssl_mode: Optional[str] = typer.Option(
+        None,
+        "--ssl-mode",
+        help="SSL mode (disable, allow, prefer, require, verify-ca, verify-full for PostgreSQL; DISABLED, PREFERRED, REQUIRED, VERIFY_CA, VERIFY_IDENTITY for MySQL)",
+    ),
+    ssl_ca: Optional[str] = typer.Option(
+        None, "--ssl-ca", help="SSL CA certificate file path"
+    ),
+    ssl_cert: Optional[str] = typer.Option(
+        None, "--ssl-cert", help="SSL client certificate file path"
+    ),
+    ssl_key: Optional[str] = typer.Option(
+        None, "--ssl-key", help="SSL client private key file path"
+    ),
     interactive: bool = typer.Option(
         True, "--interactive/--no-interactive", help="Use interactive mode"
     ),
@@ -80,6 +94,63 @@ def add_database(
 
             # Ask for password
             password = getpass.getpass("Password (stored in your OS keychain): ")
+
+            # Ask for SSL configuration
+            if questionary.confirm("Configure SSL/TLS settings?", default=False).ask():
+                if type == "postgresql":
+                    ssl_mode = (
+                        ssl_mode
+                        or questionary.select(
+                            "SSL mode for PostgreSQL:",
+                            choices=[
+                                "disable",
+                                "allow",
+                                "prefer",
+                                "require",
+                                "verify-ca",
+                                "verify-full",
+                            ],
+                            default="prefer",
+                        ).ask()
+                    )
+                elif type == "mysql":
+                    ssl_mode = (
+                        ssl_mode
+                        or questionary.select(
+                            "SSL mode for MySQL:",
+                            choices=[
+                                "DISABLED",
+                                "PREFERRED",
+                                "REQUIRED",
+                                "VERIFY_CA",
+                                "VERIFY_IDENTITY",
+                            ],
+                            default="PREFERRED",
+                        ).ask()
+                    )
+
+                if ssl_mode and ssl_mode not in ["disable", "DISABLED"]:
+                    if questionary.confirm(
+                        "Specify SSL certificate files?", default=False
+                    ).ask():
+                        ssl_ca = (
+                            ssl_ca or questionary.path("SSL CA certificate file:").ask()
+                        )
+                        if questionary.confirm(
+                            "Specify client certificate?", default=False
+                        ).ask():
+                            ssl_cert = (
+                                ssl_cert
+                                or questionary.path(
+                                    "SSL client certificate file:"
+                                ).ask()
+                            )
+                            ssl_key = (
+                                ssl_key
+                                or questionary.path(
+                                    "SSL client private key file:"
+                                ).ask()
+                            )
     else:
         # Non-interactive mode - use provided values or defaults
         if type == "sqlite":
@@ -123,6 +194,10 @@ def add_database(
         port=port,
         database=database,
         username=username,
+        ssl_mode=ssl_mode,
+        ssl_ca=ssl_ca,
+        ssl_cert=ssl_cert,
+        ssl_key=ssl_key,
     )
 
     try:
@@ -157,10 +232,21 @@ def list_databases():
     table.add_column("Port", style="yellow")
     table.add_column("Database", style="blue")
     table.add_column("Username", style="white")
+    table.add_column("SSL", style="bright_green")
     table.add_column("Default", style="bold red")
 
     for db in databases:
         is_default = "✓" if db.name == default_name else ""
+
+        # Format SSL status
+        ssl_status = ""
+        if db.ssl_mode:
+            ssl_status = db.ssl_mode
+            if db.ssl_ca or db.ssl_cert:
+                ssl_status += " (certs)"
+        else:
+            ssl_status = "disabled" if db.type != "sqlite" else "N/A"
+
         table.add_row(
             db.name,
             db.type,
@@ -168,6 +254,7 @@ def list_databases():
             str(db.port) if db.port else "",
             db.database,
             db.username,
+            ssl_status,
             is_default,
         )
 

sqlsaber/config/database.py

@@ -25,6 +25,9 @@ class DatabaseConfig:
     username: Optional[str]
     password: Optional[str] = None
     ssl_mode: Optional[str] = None
+    ssl_ca: Optional[str] = None
+    ssl_cert: Optional[str] = None
+    ssl_key: Optional[str] = None
     schema: Optional[str] = None
 
     def to_connection_string(self) -> str:
@@ -34,21 +37,57 @@ class DatabaseConfig:
         if self.type == "postgresql":
             if not all([self.host, self.port, self.username]):
                 raise ValueError("Host, port, and username are required for PostgreSQL")
+
+            # Build base connection string
             if password:
                 encoded_password = quote_plus(password)
-                return f"postgresql://{self.username}:{encoded_password}@{self.host}:{self.port}/{self.database}"
+                base_url = f"postgresql://{self.username}:{encoded_password}@{self.host}:{self.port}/{self.database}"
             else:
-                return f"postgresql://{self.username}@{self.host}:{self.port}/{self.database}"
+                base_url = f"postgresql://{self.username}@{self.host}:{self.port}/{self.database}"
+
+            # Add SSL parameters
+            ssl_params = []
+            if self.ssl_mode:
+                ssl_params.append(f"sslmode={self.ssl_mode}")
+            if self.ssl_ca:
+                ssl_params.append(f"sslrootcert={quote_plus(self.ssl_ca)}")
+            if self.ssl_cert:
+                ssl_params.append(f"sslcert={quote_plus(self.ssl_cert)}")
+            if self.ssl_key:
+                ssl_params.append(f"sslkey={quote_plus(self.ssl_key)}")
+
+            if ssl_params:
+                return f"{base_url}?{'&'.join(ssl_params)}"
+            return base_url
+
         elif self.type == "mysql":
             if not all([self.host, self.port, self.username]):
                 raise ValueError("Host, port, and username are required for MySQL")
+
+            # Build base connection string
             if password:
                 encoded_password = quote_plus(password)
-                return f"mysql://{self.username}:{encoded_password}@{self.host}:{self.port}/{self.database}"
+                base_url = f"mysql://{self.username}:{encoded_password}@{self.host}:{self.port}/{self.database}"
             else:
-                return (
+                base_url = (
                     f"mysql://{self.username}@{self.host}:{self.port}/{self.database}"
                 )
+
+            # Add SSL parameters
+            ssl_params = []
+            if self.ssl_mode:
+                ssl_params.append(f"ssl_mode={self.ssl_mode}")
+            if self.ssl_ca:
+                ssl_params.append(f"ssl_ca={quote_plus(self.ssl_ca)}")
+            if self.ssl_cert:
+                ssl_params.append(f"ssl_cert={quote_plus(self.ssl_cert)}")
+            if self.ssl_key:
+                ssl_params.append(f"ssl_key={quote_plus(self.ssl_key)}")
+
+            if ssl_params:
+                return f"{base_url}?{'&'.join(ssl_params)}"
+            return base_url
+
         elif self.type == "sqlite":
             return f"sqlite:///{self.database}"
         else:
@@ -82,6 +121,9 @@ class DatabaseConfig:
             "database": self.database,
             "username": self.username,
             "ssl_mode": self.ssl_mode,
+            "ssl_ca": self.ssl_ca,
+            "ssl_cert": self.ssl_cert,
+            "ssl_key": self.ssl_key,
             "schema": self.schema,
         }
 
@@ -96,6 +138,9 @@ class DatabaseConfig:
             database=data["database"],
             username=data["username"],
             ssl_mode=data.get("ssl_mode"),
+            ssl_ca=data.get("ssl_ca"),
+            ssl_cert=data.get("ssl_cert"),
+            ssl_key=data.get("ssl_key"),
             schema=data.get("schema"),
         )
 

sqlsaber/database/connection.py

@@ -2,7 +2,8 @@
 
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional
-from urllib.parse import urlparse
+from urllib.parse import urlparse, parse_qs
+import ssl
 
 import aiomysql
 import aiosqlite
@@ -42,13 +43,65 @@ class PostgreSQLConnection(BaseDatabaseConnection):
     def __init__(self, connection_string: str):
         super().__init__(connection_string)
         self._pool: Optional[asyncpg.Pool] = None
+        self._ssl_context = self._create_ssl_context()
+
+    def _create_ssl_context(self) -> Optional[ssl.SSLContext]:
+        """Create SSL context from connection string parameters."""
+        parsed = urlparse(self.connection_string)
+        if not parsed.query:
+            return None
+
+        params = parse_qs(parsed.query)
+        ssl_mode = params.get("sslmode", [None])[0]
+
+        if not ssl_mode or ssl_mode == "disable":
+            return None
+
+        # Create SSL context based on mode
+        if ssl_mode in ["require", "verify-ca", "verify-full"]:
+            ssl_context = ssl.create_default_context()
+
+            # Configure certificate verification
+            if ssl_mode == "require":
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            elif ssl_mode == "verify-ca":
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_REQUIRED
+            elif ssl_mode == "verify-full":
+                ssl_context.check_hostname = True
+                ssl_context.verify_mode = ssl.CERT_REQUIRED
+
+            # Load certificates if provided
+            ssl_ca = params.get("sslrootcert", [None])[0]
+            ssl_cert = params.get("sslcert", [None])[0]
+            ssl_key = params.get("sslkey", [None])[0]
+
+            if ssl_ca:
+                ssl_context.load_verify_locations(ssl_ca)
+
+            if ssl_cert and ssl_key:
+                ssl_context.load_cert_chain(ssl_cert, ssl_key)
+
+            return ssl_context
+
+        return None
 
     async def get_pool(self) -> asyncpg.Pool:
         """Get or create connection pool."""
         if self._pool is None:
-            self._pool = await asyncpg.create_pool(
-                self.connection_string, min_size=1, max_size=10
-            )
+            # Create pool with SSL context if configured
+            if self._ssl_context:
+                self._pool = await asyncpg.create_pool(
+                    self.connection_string,
+                    min_size=1,
+                    max_size=10,
+                    ssl=self._ssl_context,
+                )
+            else:
+                self._pool = await asyncpg.create_pool(
+                    self.connection_string, min_size=1, max_size=10
+                )
         return self._pool
 
     async def close(self):
@@ -94,19 +147,65 @@ class MySQLConnection(BaseDatabaseConnection):
         self.user = parsed.username or ""
         self.password = parsed.password or ""
 
+        # Parse SSL parameters
+        self.ssl_params = {}
+        if parsed.query:
+            params = parse_qs(parsed.query)
+
+            ssl_mode = params.get("ssl_mode", [None])[0]
+            if ssl_mode:
+                # Map SSL modes to aiomysql SSL parameters
+                if ssl_mode.upper() == "DISABLED":
+                    self.ssl_params["ssl"] = None
+                elif ssl_mode.upper() in [
+                    "PREFERRED",
+                    "REQUIRED",
+                    "VERIFY_CA",
+                    "VERIFY_IDENTITY",
+                ]:
+                    ssl_context = ssl.create_default_context()
+
+                    if ssl_mode.upper() == "REQUIRED":
+                        ssl_context.check_hostname = False
+                        ssl_context.verify_mode = ssl.CERT_NONE
+                    elif ssl_mode.upper() == "VERIFY_CA":
+                        ssl_context.check_hostname = False
+                        ssl_context.verify_mode = ssl.CERT_REQUIRED
+                    elif ssl_mode.upper() == "VERIFY_IDENTITY":
+                        ssl_context.check_hostname = True
+                        ssl_context.verify_mode = ssl.CERT_REQUIRED
+
+                    # Load certificates if provided
+                    ssl_ca = params.get("ssl_ca", [None])[0]
+                    ssl_cert = params.get("ssl_cert", [None])[0]
+                    ssl_key = params.get("ssl_key", [None])[0]
+
+                    if ssl_ca:
+                        ssl_context.load_verify_locations(ssl_ca)
+
+                    if ssl_cert and ssl_key:
+                        ssl_context.load_cert_chain(ssl_cert, ssl_key)
+
+                    self.ssl_params["ssl"] = ssl_context
+
     async def get_pool(self) -> aiomysql.Pool:
         """Get or create connection pool."""
         if self._pool is None:
-            self._pool = await aiomysql.create_pool(
-                host=self.host,
-                port=self.port,
-                user=self.user,
-                password=self.password,
-                db=self.database,
-                minsize=1,
-                maxsize=10,
-                autocommit=False,
-            )
+            pool_kwargs = {
+                "host": self.host,
+                "port": self.port,
+                "user": self.user,
+                "password": self.password,
+                "db": self.database,
+                "minsize": 1,
+                "maxsize": 10,
+                "autocommit": False,
+            }
+
+            # Add SSL parameters if configured
+            pool_kwargs.update(self.ssl_params)
+
+            self._pool = await aiomysql.create_pool(**pool_kwargs)
         return self._pool
 
     async def close(self):

{sqlsaber-0.1.0.dist-info → sqlsaber-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.1.0
+Version: 0.2.0
 Summary: SQLSaber - Agentic SQL assistant like Claude Code
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlsaber-0.1.0.dist-info → sqlsaber-0.2.0.dist-info}/RECORD

@@ -6,7 +6,7 @@ sqlsaber/agents/base.py,sha256=UUSGhoJImATXrYS7yrLR2qjg1iFW4udOUdRaV3Ryk5s,2086
 sqlsaber/agents/streaming.py,sha256=0bNzd_JhLlgQB40pf9FZFMvmU9Q7W6D9BmglA1rIGqw,850
 sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
 sqlsaber/cli/commands.py,sha256=Adrt_0LRgykb2FZ4F0TQpuBM8Z0qgfbggn0FexcVALI,4094
-sqlsaber/cli/database.py,sha256=W-tJqmihKjZhoe5AGpQKe0txzLIgRVGikZHM_ELAbnQ,9138
+sqlsaber/cli/database.py,sha256=ZOaW94dCM8_RUT5OZzI6-lbVmSYxSjdmAdYa3Nf_d9g,12633
 sqlsaber/cli/display.py,sha256=5J4AgJADmMwKi9Aq5u6_MKRO1TA6unS4F4RUfml_sfU,7651
 sqlsaber/cli/interactive.py,sha256=y92rdoM49SOSwEctm9ZcrEN220fhJ_DMHPSd_7KsORg,3701
 sqlsaber/cli/memory.py,sha256=LW4ZF2V6Gw6hviUFGZ4ym9ostFCwucgBTIMZ3EANO-I,7671
@@ -14,10 +14,10 @@ sqlsaber/cli/models.py,sha256=3IcXeeU15IQvemSv-V-RQzVytJ3wuQ4YmWk89nTDcSE,7813
 sqlsaber/cli/streaming.py,sha256=5QGAYTAvg9mzQLxDEVtdDH-TIbGfYYzMOLoOYPrHPu0,3788
 sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
 sqlsaber/config/api_keys.py,sha256=kLdoExF_My9ojmdhO5Ca7-ZeowsO0v1GVa_QT5jjUPo,3658
-sqlsaber/config/database.py,sha256=FX4zwmOkW-lvIH--c8xRyoyyjYLjn3OQTkSruEw-aQY,8790
+sqlsaber/config/database.py,sha256=hrIr5IIqhkOpjJ2A4oaeMvTqWqNDdlJiVWQTaBudVQM,10388
 sqlsaber/config/settings.py,sha256=zjQ7nS3ybcCb88Ea0tmwJox5-q0ettChZw89ZqRVpX8,3975
 sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
-sqlsaber/database/connection.py,sha256=Z1iIRBIoPQcCfBliROLeebEQeI7ggu-hh_G1l-tzhIM,6672
+sqlsaber/database/connection.py,sha256=1lMQ2LhxlUIkl_msGzuNXczI_tNp0WBgfsdqDC2nxsw,10479
 sqlsaber/database/schema.py,sha256=gURfCFVE--UWIqD_0StqS2NMB9VIPpqczBEoS2GnKR4,27025
 sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
 sqlsaber/memory/manager.py,sha256=ML2NEO5Z4Aw36sEI9eOvWVnjl-qT2VOTojViJAj7Seo,2777
@@ -25,8 +25,8 @@ sqlsaber/memory/storage.py,sha256=DvZBsSPaAfk_DqrNEn86uMD-TQsWUI6rQLfNw6PSCB8,57
 sqlsaber/models/__init__.py,sha256=RJ7p3WtuSwwpFQ1Iw4_DHV2zzCtHqIzsjJzxv8kUjUE,287
 sqlsaber/models/events.py,sha256=55m41tDwMsFxnKKA5_VLJz8iV-V4Sq3LDfta4VoutJI,737
 sqlsaber/models/types.py,sha256=3U_30n91EB3IglBTHipwiW4MqmmaA2qfshfraMZyPps,896
-sqlsaber-0.1.0.dist-info/METADATA,sha256=37Xik234wv415wWsvIWr4XFjzHiQV39EnDAYyZsMgXA,3953
-sqlsaber-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.1.0.dist-info/entry_points.txt,sha256=POwcsEskUp7xQQWabrAi6Eawz4qc5eBlB3KzAiBq-Y0,124
-sqlsaber-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.1.0.dist-info/RECORD,,
+sqlsaber-0.2.0.dist-info/METADATA,sha256=EUgK7o9feWxmsx_pr9DwER6_t6db7ZaYSghwUKKYPao,3953
+sqlsaber-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.2.0.dist-info/entry_points.txt,sha256=POwcsEskUp7xQQWabrAi6Eawz4qc5eBlB3KzAiBq-Y0,124
+sqlsaber-0.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.2.0.dist-info/RECORD,,