sql-safe-mcp 1.2.0__py3-none-any.whl

sql_safe_mcp/service.py

@@ -0,0 +1,325 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import TypeVar
+
+from sqlalchemy import Connection, Engine
+from sqlalchemy.exc import DBAPIError, OperationalError, SQLAlchemyError
+from sqlalchemy.exc import TimeoutError as SQLAlchemyTimeoutError
+
+from sql_safe_mcp.config import AppConfig, ServerConfig
+from sql_safe_mcp.db.extras import extras_for
+from sql_safe_mcp.db.reflection import get_table_definition as reflect_table_definition
+from sql_safe_mcp.db.reflection import list_tables as reflect_tables
+from sql_safe_mcp.db.registry import EngineRegistry
+from sql_safe_mcp.errors import DomainError, ErrorCode
+from sql_safe_mcp.models import (
+    ColumnSource,
+    DatabaseList,
+    DatabaseSummary,
+    ServerList,
+    ServerSummary,
+    SqlColumn,
+    SqlResult,
+    StoredProcedureDefinition,
+    StoredProcedureList,
+    StoredProcedureSummary,
+    TableDefinition,
+    TableList,
+    TableSummary,
+)
+from sql_safe_mcp.security.dialect import dialect_for
+from sql_safe_mcp.security.executor import execute_validated
+from sql_safe_mcp.security.pipeline import validate_sql
+from sql_safe_mcp.security.schema import ReflectedCatalog, SchemaCache, TableCatalog
+from sql_safe_mcp.security.tokens import TokenKeyRegistry
+
+logger = logging.getLogger(__name__)
+CatalogFactory = Callable[[Connection, str, str], TableCatalog]
+_SCHEMA_CACHE_ENTRIES = 1024
+_SCHEMA_CACHE_TTL_SECONDS = 300.0
+T = TypeVar("T")
+
+
+def _contains(value: str, needle: str | None) -> bool:
+    return needle is None or needle.casefold() in value.casefold()
+
+
+def _qualified_name(schema: str | None, name: str) -> str:
+    return name if schema is None else f"{schema}.{name}"
+
+
+class DatabaseService:
+    def __init__(
+        self,
+        config: AppConfig,
+        registry: EngineRegistry,
+        catalog_factory: CatalogFactory | None = None,
+    ) -> None:
+        self.config = config
+        self.registry = registry
+        self._tokens = TokenKeyRegistry.from_config(config)
+        self._schema_cache = SchemaCache(_SCHEMA_CACHE_ENTRIES, _SCHEMA_CACHE_TTL_SECONDS)
+        self._catalog_factory = catalog_factory or self._reflected_catalog
+
+    def _reflected_catalog(self, connection: Connection, alias: str, database: str) -> TableCatalog:
+        return ReflectedCatalog(connection, self._schema_cache, alias, database)
+
+    def _server(self, alias: str) -> ServerConfig:
+        try:
+            return self.config.servers[alias]
+        except KeyError as exc:
+            raise DomainError(
+                ErrorCode.UNKNOWN_SERVER,
+                f"Unknown configured server {alias!r}.",
+                "Call list_servers to discover configured aliases.",
+            ) from exc
+
+    async def _run(self, alias: str, database: str | None, operation: Callable[[Engine], T]) -> T:
+        self._server(alias)
+        try:
+            return await self.registry.run(alias, database, operation)
+        except DomainError:
+            raise
+        except SQLAlchemyTimeoutError as exc:
+            raise DomainError(
+                ErrorCode.TIMEOUT,
+                "The database operation timed out.",
+                retryable=True,
+            ) from exc
+        except DBAPIError as exc:
+            message = str(exc.orig).casefold()
+            if any(value in message for value in ("timeout", "timed out", "hyt00", "hyt01")):
+                raise DomainError(
+                    ErrorCode.TIMEOUT, "The database operation timed out.", retryable=True
+                ) from exc
+            if any(value in message for value in ("permission", "denied", "not authorized")):
+                raise DomainError(
+                    ErrorCode.ACCESS_DENIED, "The database denied this operation."
+                ) from exc
+            if any(
+                value in message for value in ("cannot open database", "(4060)", "08001", "08004")
+            ):
+                raise DomainError(
+                    ErrorCode.CONNECTION_FAILED,
+                    "Could not connect to the configured database server.",
+                    retryable=True,
+                ) from exc
+            if isinstance(exc, OperationalError):
+                raise DomainError(
+                    ErrorCode.CONNECTION_FAILED,
+                    "Could not connect to the configured database server.",
+                    retryable=True,
+                ) from exc
+            error = DomainError.unexpected()
+            logger.error("Database operation failed; reference=%s", error.correlation_id)
+            raise error from exc
+        except SQLAlchemyError as exc:
+            error = DomainError.unexpected()
+            logger.error("SQLAlchemy operation failed; reference=%s", error.correlation_id)
+            raise error from exc
+        except Exception as exc:
+            error = DomainError.unexpected()
+            logger.error(
+                "Unexpected database operation failure; reference=%s", error.correlation_id
+            )
+            raise error from exc
+
+    def list_servers(self) -> ServerList:
+        return ServerList(
+            servers=[
+                ServerSummary(name=alias, engine=server.engine, access_level=server.access_level)
+                for alias, server in sorted(
+                    self.config.servers.items(), key=lambda item: item[0].casefold()
+                )
+            ]
+        )
+
+    async def list_databases(self, server: str, name_contains: str | None = None) -> DatabaseList:
+        configured = self._server(server)
+
+        def operation(engine: Engine) -> list[str]:
+            with engine.connect() as connection:
+                return extras_for(configured.engine).list_databases(connection)
+
+        names = await self._run(server, None, operation)
+        return DatabaseList(
+            databases=[
+                DatabaseSummary(name=name)
+                for name in sorted(names, key=str.casefold)
+                if _contains(name, name_contains)
+            ]
+        )
+
+    async def list_tables(
+        self,
+        server: str,
+        database: str,
+        schema: str | None = None,
+        name_contains: str | None = None,
+    ) -> TableList:
+        self._server(server)
+
+        def operation(engine: Engine) -> list[TableSummary]:
+            with engine.connect() as connection:
+                return reflect_tables(connection)
+
+        tables = await self._run(server, database, operation)
+        selected = [
+            table
+            for table in tables
+            if (schema is None or (table.schema_ or "").casefold() == schema.casefold())
+            and _contains(table.name, name_contains)
+        ]
+        selected.sort(key=lambda table: ((table.schema_ or "").casefold(), table.name.casefold()))
+        return TableList(tables=selected)
+
+    @staticmethod
+    def _resolve_table(tables: list[TableSummary], table: str, schema: str | None) -> TableSummary:
+        matches = [
+            item
+            for item in tables
+            if item.name.casefold() == table.casefold()
+            and (schema is None or (item.schema_ or "").casefold() == schema.casefold())
+        ]
+        if not matches:
+            raise DomainError(ErrorCode.NOT_FOUND, f"Table {table!r} was not found.")
+        if len(matches) > 1:
+            candidates = ", ".join(_qualified_name(item.schema_, item.name) for item in matches)
+            raise DomainError(
+                ErrorCode.AMBIGUOUS_OBJECT,
+                f"Table {table!r} is ambiguous.",
+                f"Specify schema; candidates: {candidates}.",
+            )
+        return matches[0]
+
+    async def get_table_definition(
+        self, server: str, database: str, table: str, schema: str | None = None
+    ) -> TableDefinition:
+        self._server(server)
+
+        def operation(engine: Engine) -> TableDefinition:
+            with engine.connect() as connection:
+                selected = self._resolve_table(reflect_tables(connection), table, schema)
+                return reflect_table_definition(connection, selected.schema_, selected.name)
+
+        return await self._run(server, database, operation)
+
+    async def list_stored_procedures(
+        self,
+        server: str,
+        database: str,
+        schema: str | None = None,
+        name_contains: str | None = None,
+    ) -> StoredProcedureList:
+        configured = self._server(server)
+
+        def operation(engine: Engine) -> list[StoredProcedureSummary]:
+            with engine.connect() as connection:
+                return extras_for(configured.engine).list_stored_procedures(connection, database)
+
+        procedures = await self._run(server, database, operation)
+        selected = [
+            item
+            for item in procedures
+            if (schema is None or (item.schema_ or "").casefold() == schema.casefold())
+            and _contains(item.name, name_contains)
+        ]
+        selected.sort(key=lambda item: ((item.schema_ or "").casefold(), item.name.casefold()))
+        return StoredProcedureList(stored_procedures=selected)
+
+    async def get_stored_procedure(
+        self,
+        server: str,
+        database: str,
+        name: str,
+        schema: str | None = None,
+    ) -> StoredProcedureDefinition:
+        configured = self._server(server)
+        listing = await self.list_stored_procedures(server, database, schema)
+        matches = [
+            item for item in listing.stored_procedures if item.name.casefold() == name.casefold()
+        ]
+        if not matches:
+            raise DomainError(ErrorCode.NOT_FOUND, f"Stored procedure {name!r} was not found.")
+        if len(matches) > 1:
+            candidates = ", ".join(_qualified_name(item.schema_, item.name) for item in matches)
+            raise DomainError(
+                ErrorCode.AMBIGUOUS_OBJECT,
+                f"Stored procedure {name!r} is ambiguous.",
+                f"Specify schema; candidates: {candidates}.",
+            )
+        selected = matches[0]
+
+        def operation(engine: Engine) -> StoredProcedureDefinition | None:
+            with engine.connect() as connection:
+                return extras_for(configured.engine).get_stored_procedure(
+                    connection, database, selected.schema_, selected.name
+                )
+
+        result = await self._run(server, database, operation)
+        if result is None:
+            raise DomainError(ErrorCode.NOT_FOUND, f"Stored procedure {name!r} was not found.")
+        if (
+            result.definition is not None
+            and len(result.definition) > self.config.runtime.max_definition_chars
+        ):
+            raise DomainError(
+                ErrorCode.DEFINITION_TOO_LARGE,
+                "Stored procedure definition exceeds the configured response limit.",
+            )
+        return result
+
+    async def execute_sql(
+        self, server: str, database: str, sql: str, max_rows: int | None = None
+    ) -> SqlResult:
+        configured = self._server(server)
+        if configured.access_level != "pii_safe" or configured.pii is None:
+            raise DomainError(
+                ErrorCode.ACCESS_LEVEL_DENIED,
+                "execute_sql is available only for pii_safe servers.",
+                "Use a server configured with access_level pii_safe.",
+            )
+        runtime = self.config.runtime
+        rows_limit = runtime.default_max_rows if max_rows is None else max_rows
+        codec = self._tokens.codec_for(server)
+        pii = configured.pii
+        dialect = dialect_for(configured.engine)
+
+        def operation(engine: Engine) -> SqlResult:
+            with engine.connect() as connection:
+                validated = validate_sql(
+                    sql,
+                    alias=server,
+                    database=database,
+                    catalog=self._catalog_factory(connection, server, database),
+                    pii_config=pii,
+                    codec=codec,
+                    runtime=runtime,
+                    max_rows=rows_limit,
+                    dialect=dialect,
+                )
+                executed = execute_validated(connection, validated, codec)
+            return SqlResult(
+                columns=[
+                    SqlColumn(
+                        name=column.name,
+                        source=None
+                        if column.source is None
+                        else ColumnSource(
+                            schema=column.source.schema or None,
+                            table=column.source.table,
+                            column=column.source.column,
+                        ),
+                        protected=column.protected,
+                        encoding=column.encoding,
+                    )
+                    for column in executed.columns
+                ],
+                rows=[list(row) for row in executed.rows],
+                row_count=len(executed.rows),
+                truncated=executed.truncated,
+            )
+
+        return await self._run(server, database, operation)

sql_safe_mcp-1.2.0.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.5
+Name: sql-safe-mcp
+Version: 1.2.0
+Summary: Minimal, read-only, PII-safe MCP server for SQL databases.
+License: MIT License
+        
+        Copyright (c) 2026 Anton Padapryhara
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: <3.15,>=3.12
+Requires-Dist: anyio<5,>=4.8
+Requires-Dist: cryptography<47,>=46.0.7
+Requires-Dist: mcp<3,>=2
+Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: pymysql>=1.2.3
+Requires-Dist: pyodbc<6,>=5.2
+Requires-Dist: pyyaml<7,>=6
+Requires-Dist: sqlalchemy<3,>=2.0
+Requires-Dist: sqlglot<31,>=30.18
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# sql-safe-mcp
+
+A read-only, PII-safe SQL Server, MySQL and MariaDB MCP server for coding agents: schema knowledge and safe queries, with no way to change or leak data.
+
+[![CI](https://github.com/proprock/sql-safe-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/proprock/sql-safe-mcp/actions/workflows/ci.yml)
+[![Release](https://img.shields.io/github/v/release/proprock/sql-safe-mcp)](https://github.com/proprock/sql-safe-mcp/releases)
+[![PyPI Version](https://img.shields.io/pypi/v/sql-safe-mcp)](https://pypi.org/project/sql-safe-mcp/)
+[![Python](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+[![Model Context Protocol compatible](https://img.shields.io/badge/Model_Context_Protocol-compatible-000000?logo=modelcontextprotocol&logoColor=white)](https://modelcontextprotocol.io)
+[![MCP Registry: io.github.proprock/sql-safe-mcp](https://img.shields.io/badge/MCP_Registry-io.github.proprock%2Fsql--mini--mcp-000000?logo=modelcontextprotocol&logoColor=white)](server.json)
+
+<img src="https://raw.githubusercontent.com/proprock/sql-safe-mcp/master/images/luna-guard.jpg" alt="Read the data. Protect the identity." width="760">
+
+<i>Read the data. Protect the identity.</i>
+
+</div>
+
+<!-- mcp-name: io.github.proprock/sql-safe-mcp -->
+
+General-purpose database MCP servers hand the agent a raw SQL prompt and dozens of tools. This
+server gives a coding agent the schema knowledge it needs to write correct code - servers,
+databases, tables, columns, keys, indexes, stored procedures - and, on servers you mark
+`pii_safe`, a way to look at real rows without ever seeing the personal data in them.
+
+## Read-only by design. PII-safe by default
+
+- **Read-only by construction** - seven tools, all annotated read-only. No tool writes data, and
+  the server never executes SQL an agent wrote: metadata comes from SQLAlchemy Inspector and fixed
+  catalog queries, and `execute_sql` runs only a validated, regenerated `SELECT`.
+- **PII-safe by default** - on a `pii_safe` server, the columns you configure come back as
+  alias-bound, authenticated tokens (`pii:v1:...`), never as plaintext. An agent can still
+  project, count, and filter on them with `=` and `IN` using tokens it was given, so it can follow
+  a record without reading it. Tokens do not work on another server alias or with another key.
+- **Fails closed** - SQL validation is an allowlist. Unknown syntax, unresolved lineage, and
+  unsupported protected-value types are refused, not guessed at. The verification evidence is in
+  the [security model](SECURITY-MODEL.md).
+- **Least access first** - `access_level: metadata` (the default) exposes schema only;
+  `execute_sql` needs an explicit `pii_safe` alias with its own key. Database permissions stay the
+  primary control, so use a least-privilege login.
+
+## Also
+
+- **Your aliases, not your network** - the agent sees only the server aliases you configure. There
+  is no network discovery, and the catalog is not published as MCP resources.
+- **Secrets stay out of sight** - connection URLs live in YAML with `${NAME}` placeholders resolved
+  from the environment. They never appear in logs or model-visible errors.
+- **Compact, predictable output** - object-rooted results with stable sorting, literal
+  case-insensitive name filters, and stored procedure lists that do not expand definitions.
+- **Errors an agent can act on** - an ambiguous name lists the candidate schemas. Errors never
+  contain connection details, credentials, keys, tokens, or rows.
+- **On PyPI** - `uvx sql-safe-mcp`, no repo clone required.
+
+| Tool | Access | Purpose |
+|---|---|---|
+| `list_servers` | 🟢 read | Configured server aliases |
+| `list_databases` | 🟢 read | Databases visible to the credentials |
+| `list_tables` | 🟢 read | Base tables, filtered by schema or name |
+| `get_table_definition` | 🟢 read | Columns, keys, constraints, and indexes of one table |
+| `list_stored_procedures` | 🟢 read | Stored procedures, without definitions |
+| `get_stored_procedure` | 🟢 read | The definition of one stored procedure |
+| `execute_sql` | 🟢 read | One restricted `SELECT` on a `pii_safe` server; protected columns return tokens |
+
+> [!NOTE]
+> **Status:** SQL Server supports every tool. MySQL and MariaDB (`engine: mysql` or `mariadb`,
+> `mysql+pymysql` URLs) support every tool too. `schema` is always `null` there because the
+> database is the catalog, and `execute_sql` uses `LIMIT` instead of `TOP`. See
+> [ARCHITECTURE.md](ARCHITECTURE.md).
+
+- [Install](#install)
+- [Configure](#configure)
+- [PII-safe queries](#pii-safe-queries)
+- [Security](#security)
+- [Contributing](#contributing)
+
+More detail lives in [`docs/`](docs): the [configuration reference](docs/configuration.md),
+[what the tools return](docs/tools.md), and the [security model](SECURITY-MODEL.md).
+
+## Install
+
+```bash
+uvx sql-safe-mcp
+```
+
+or
+
+```bash
+pip install sql-safe-mcp
+```
+
+Pin a version when you want a fixed surface: `uvx sql-safe-mcp==1.2.0`.
+
+Requires Python 3.12+, [uv](https://docs.astral.sh/uv/) (or `pip`), and
+[Microsoft ODBC Driver 18 for SQL Server](https://learn.microsoft.com/sql/connect/odbc/download-odbc-driver-for-sql-server)
+when you connect to SQL Server. MySQL and MariaDB use the bundled PyMySQL driver and need nothing
+else.
+
+Verified against SQL Server 2022, MySQL 8.4, and MariaDB 11.4 (see [CHECKS.md](CHECKS.md)).
+
+## Configure
+
+Copy [sql-safe-mcp.example.yaml](sql-safe-mcp.example.yaml) to `sql-safe-mcp.yaml`, list your
+servers, and keep credentials in environment variables:
+
+```yaml
+version: 1
+servers:
+  reporting:
+    engine: sqlserver
+    access_level: metadata
+    connection_url: "${REPORTING_SQL_URL}"
+```
+
+Point the server at the file with `SQL_SAFE_MCP_CONFIG` (or `--config`), and check it without
+connecting to any database:
+
+```bash
+SQL_SAFE_MCP_CONFIG=sql-safe-mcp.yaml uvx sql-safe-mcp --check-config
+```
+
+Configuration is validated at startup, and an error names the problem without printing a URL or
+secret. Keep credentials in the host's own configuration and never commit them. The server acts
+with the database account's permissions, so use a dedicated login with the least access the job
+needs. Every setting, including the runtime limits, is in
+[configuration.md](docs/configuration.md).
+
+<details>
+<summary><b>Claude Code</b></summary>
+
+```bash
+claude mcp add --env SQL_SAFE_MCP_CONFIG=/path/to/sql-safe-mcp.yaml --env REPORTING_SQL_URL=mssql+pyodbc://... --transport stdio sql-safe -- uvx sql-safe-mcp
+```
+
+Put at least one other option between the last `--env` and the server name, as above - the CLI
+otherwise reads the name as another `KEY=value` pair.
+
+</details>
+
+<details>
+<summary><b>Claude Desktop</b></summary>
+
+In `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "sql-safe": {
+      "command": "uvx",
+      "args": ["sql-safe-mcp"],
+      "env": {
+        "SQL_SAFE_MCP_CONFIG": "/path/to/sql-safe-mcp.yaml",
+        "REPORTING_SQL_URL": "mssql+pyodbc://..."
+      }
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary><b>Codex CLI</b></summary>
+
+```bash
+codex mcp add sql-safe --env SQL_SAFE_MCP_CONFIG=/path/to/sql-safe-mcp.yaml --env REPORTING_SQL_URL=mssql+pyodbc://... -- uvx sql-safe-mcp
+```
+
+</details>
+
+<details>
+<summary><b>Any other stdio host</b></summary>
+
+Command `uvx`, argument `sql-safe-mcp`, and the environment variables your configuration
+references, plus `SQL_SAFE_MCP_CONFIG`. The server speaks MCP over stdio and logs only to stderr.
+
+</details>
+
+## PII-safe queries
+
+Mark an alias `access_level: pii_safe`, give it its own key, and list the protected columns:
+
+```yaml
+servers:
+  legacy_prod:
+    engine: sqlserver
+    access_level: pii_safe
+    connection_url: "${LEGACY_PROD_SQL_URL}"
+    pii_key_env: LEGACY_PROD_PII_KEY
+    pii:
+      rules:
+        - database: "*"
+          schema: dbo
+          table: Users
+          columns: [Email, FirstName, LastName]
+```
+
+`execute_sql` then accepts one restricted `SELECT`. Protected cells come back as tokens, and a
+token is accepted only in `=` and `IN` predicates on the same alias. Protection covers the columns
+you list, so list every column that holds personal data. The rule format, key generation, and the
+accepted SQL are in [configuration.md](docs/configuration.md) and [tools.md](docs/tools.md).
+
+## Security
+
+The MCP caller, SQL input, database metadata, rows, and tokens are untrusted; the operator, the
+process environment, and the database credentials are the trusted boundary. Database permissions
+remain the primary authorization control - this server never widens them. The full model and its
+verification are in [SECURITY-MODEL.md](SECURITY-MODEL.md). To report a vulnerability,
+use the private channel in [SECURITY.md](SECURITY.md).
+
+## Contributing
+
+Setup, checks, the test commands, the branch and commit conventions, and the release model are in
+[CONTRIBUTING.md](CONTRIBUTING.md). Changes that affect someone running the server are recorded in
+[CHANGELOG.md](CHANGELOG.md).
+
+## License
+
+[MIT](LICENSE).

sql_safe_mcp-1.2.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+sql_safe_mcp/__init__.py,sha256=ZtYU3y1sIeDCTNPFFv0DQJiXDUg7P4FXl55MCPNrrY8,84
+sql_safe_mcp/__main__.py,sha256=0zI8w4Tg1orvlHngyNiVxrjhpQxhGIpKCcQGvPdLJS0,1210
+sql_safe_mcp/config.py,sha256=3J1cUwI6ygmjrEh2ODZGdOw-uttfoZWEkPo4miUjRXI,8324
+sql_safe_mcp/errors.py,sha256=2V-gXe9j3zdlQQ0ryGEaHk9ET1BxMbWrc7DXkdqOd2w,1483
+sql_safe_mcp/mcp_server.py,sha256=8rW5DR33e8oWI7bUGVinFx-hy4SVrAzaELaCOXUGzkI,4848
+sql_safe_mcp/models.py,sha256=iVXYpjllUEAHYMr0IqLLa567FRuFrVal4qd76fmau9Q,2836
+sql_safe_mcp/service.py,sha256=lP4Ji0iWNv6DFhbN7Eje8A0kipmfPCSzgLgV-ttRACg,12986
+sql_safe_mcp/db/__init__.py,sha256=9OzZMXtRCRhrc9UW7wyP3WpHqYdARd-t9CpEgNJ7n-U,34
+sql_safe_mcp/db/extras.py,sha256=b8uPnmwD93VxsmV2nZdO-jFkoQNCYOZocwHSQntV-2I,962
+sql_safe_mcp/db/mysql.py,sha256=y7xuoh2wsBEVbZyWOAUqxEFUHCL4a7bX9DlvmWC8S7o,2386
+sql_safe_mcp/db/reflection.py,sha256=rc-Wze0mCX0mim6llr2PgirjxfouMTWZHyY9J2jYzs8,4611
+sql_safe_mcp/db/registry.py,sha256=t3i4m1l8hpaM-Uh49Itm77F-lcbAvTUGRUsiwoCn7eU,4480
+sql_safe_mcp/db/sqlserver.py,sha256=RWDa42UOsDg95Afrq9ll_hdmUgIE7Q_0nrBmyoRJ2v0,2296
+sql_safe_mcp/security/__init__.py,sha256=BILBe5I3egmNNauOHkXfWCpKgGIF38rXcuRbX2RejZQ,66
+sql_safe_mcp/security/dialect.py,sha256=mrbFCYvkphuDV74CiRci5ZITCIv5p-BCqr-9ZlfPMno,1130
+sql_safe_mcp/security/executor.py,sha256=YGO9sXgj3FwfAhgx8xQbWjCEY1Dboi2Wr66bHxKye_4,4415
+sql_safe_mcp/security/lineage.py,sha256=l4bkkbZYNG0AW7Ez-17PM7S6gF4cFtAHBZWi7DRt9kA,8034
+sql_safe_mcp/security/parser.py,sha256=TCTlQmm1wsdQEOxgiM4DG7DY9ra0CpxS8fX7RsLH30w,7535
+sql_safe_mcp/security/pipeline.py,sha256=PleegA8l4fm9ENesJsmcEcsel_YnrZD-1pyaGdlRp_s,1464
+sql_safe_mcp/security/policy.py,sha256=qAyrHzsS_q2ZHEIj9H5zm-jHng9xps84nw1Z0HNDw34,3778
+sql_safe_mcp/security/reasons.py,sha256=xOzxvO0txedkjB-gt09_CZgNMda9Luuwe7n-kq2t0m8,2678
+sql_safe_mcp/security/schema.py,sha256=uhGd_79ntJb1iGT9RWymAwyTlpEEeyfMZlucWKo8ZH8,5007
+sql_safe_mcp/security/tokens.py,sha256=XnTwlYpdDxIW41aM2-tvcSA6KefAd2FMzq8_POosSWc,7134
+sql_safe_mcp/security/validated_query.py,sha256=Bi6mriaT4xkOhoF6Kh3eiKPloizrMBQrOuYtqzUDnV4,6987
+sql_safe_mcp-1.2.0.dist-info/METADATA,sha256=AVDnoiAefEp3LdeVUxC3lZKSNkk3wCQAugCzlAJ6k0s,10850
+sql_safe_mcp-1.2.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+sql_safe_mcp-1.2.0.dist-info/entry_points.txt,sha256=kHW1kqvrxB7wgJ3rckGvWR95JEoT_zjql7-ASTKcxyI,60
+sql_safe_mcp-1.2.0.dist-info/licenses/LICENSE,sha256=D5ajj8LaHI_KEmp64J78GqH7a71vwYWZIg3spYMVYJY,1074
+sql_safe_mcp-1.2.0.dist-info/RECORD,,

sql_safe_mcp-1.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.3
+Root-Is-Purelib: true
+Tag: py3-none-any

sql_safe_mcp-1.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sql-safe-mcp = sql_safe_mcp.__main__:main

sql_safe_mcp-1.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton Padapryhara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.