uc-mcp-proxy 0.1.0__tar.gz

uc_mcp_proxy-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run unit tests
+        run: uv run pytest -m unit -v --cov
+
+      - name: Build package
+        run: uv build

uc_mcp_proxy-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,23 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v4
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

uc_mcp_proxy-0.1.0/.gitignore

@@ -0,0 +1,31 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+*.egg
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Testing
+.coverage
+.pytest_cache/
+htmlcov/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# uv
+.python-version

uc_mcp_proxy-0.1.0/CLAUDE.md

@@ -0,0 +1,36 @@
+# uc-mcp-proxy
+
+MCP stdio-to-Streamable-HTTP proxy with Databricks OAuth.
+
+## Commands
+
+- `uv sync` — install all dependencies (including dev)
+- `uv run pytest -m unit -v` — run unit tests only
+- `uv run pytest -m integration -v` — run integration tests only
+- `uv run pytest -v` — run all tests
+- `uv run pytest -m unit --cov -v` — unit tests with coverage
+- `uv build` — build sdist + wheel into `dist/`
+
+## Architecture
+
+Single-module package in `src/uc_mcp_proxy/`:
+
+- `__main__.py` — CLI entry point, `DatabricksAuth` (httpx auth flow), `bridge()` (bidirectional stdio↔HTTP stream copy), `run()` (async main)
+- `__init__.py` — re-exports `DatabricksAuth`
+
+The proxy bridges an MCP stdio transport to a remote Streamable HTTP MCP server, injecting Databricks OAuth tokens on every request via `DatabricksAuth`.
+
+## Testing
+
+Tests live in `tests/` with two marker categories:
+
+- `unit` — pure unit tests, no external dependencies, fast
+- `integration` — full proxy flow tests with mocked transports
+
+All new code must have unit tests. Maintain ≥75% coverage (`fail_under = 75` in pyproject.toml).
+
+## Code Style
+
+- Use `from __future__ import annotations` in all modules
+- Type hints on all public functions
+- Keep imports sorted: stdlib → third-party → local

uc_mcp_proxy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tanner Wendland
+
+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.

uc_mcp_proxy-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: uc-mcp-proxy
+Version: 0.1.0
+Summary: MCP stdio-to-Streamable-HTTP proxy with Databricks OAuth
+Project-URL: Homepage, https://github.com/IceRhymers/uc-mcp-proxy
+Project-URL: Repository, https://github.com/IceRhymers/uc-mcp-proxy
+Project-URL: Issues, https://github.com/IceRhymers/uc-mcp-proxy/issues
+Author: Tanner Wendland
+License-Expression: MIT
+License-File: LICENSE
+Keywords: databricks,mcp,oauth,proxy,unity-catalog
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: anyio
+Requires-Dist: databricks-sdk>=0.30.0
+Requires-Dist: httpx
+Requires-Dist: mcp>=1.8
+Description-Content-Type: text/markdown
+
+# uc-mcp-proxy
+
+MCP stdio-to-Streamable-HTTP proxy with Databricks OAuth.
+
+Lets any MCP client that speaks **stdio** (e.g. Claude Desktop, Claude Code) connect to a remote **Streamable HTTP** MCP server hosted on Databricks Apps — handling OAuth authentication automatically.
+
+## Installation
+
+```bash
+# Run directly (no install needed)
+uvx uc-mcp-proxy --url https://<workspace>.databricks.com/apps/<app>/mcp
+
+# Or install globally
+uv tool install uc-mcp-proxy
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+### Claude Desktop / Claude Code (`.mcp.json`)
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "unity-catalog": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": [
+        "uc-mcp-proxy",
+        "--url", "https://<workspace>.databricks.com/apps/<app>/mcp"
+      ]
+    }
+  }
+}
+```
+
+### CLI
+
+```bash
+uc-mcp-proxy --url <MCP_SERVER_URL> [--profile <DATABRICKS_PROFILE>] [--auth-type <AUTH_TYPE>]
+```
+
+| Flag | Description |
+|------|-------------|
+| `--url` | **(required)** Remote MCP server URL |
+| `--profile` | Databricks CLI profile name (uses default if omitted) |
+| `--auth-type` | Databricks auth type, e.g. `databricks-cli` |
+
+## How It Works
+
+1. Starts an MCP **stdio** server (stdin/stdout)
+2. Connects to the remote MCP server via **Streamable HTTP**
+3. Injects a fresh Databricks OAuth token on every HTTP request
+4. Bridges messages bidirectionally between the two transports
+
+## OAuth Authentication
+
+Authentication is handled by the [Databricks SDK](https://docs.databricks.com/dev-tools/sdk-python.html), which supports multiple auth methods:
+
+- **Databricks CLI** (`databricks-cli`) — uses tokens from `~/.databrickscfg`
+- **OAuth U2M** — browser-based login flow
+- **PAT** — personal access tokens
+- **Azure / GCP / AWS** — cloud-native identity
+
+The SDK auto-detects the method, or you can force one with `--auth-type`.
+
+## Development
+
+```bash
+uv sync                        # install dependencies
+uv run pytest -m unit -v       # run unit tests
+uv run pytest -m integration -v # run integration tests
+uv build                       # build package
+```
+
+## License
+
+MIT

uc_mcp_proxy-0.1.0/README.md

@@ -0,0 +1,81 @@
+# uc-mcp-proxy
+
+MCP stdio-to-Streamable-HTTP proxy with Databricks OAuth.
+
+Lets any MCP client that speaks **stdio** (e.g. Claude Desktop, Claude Code) connect to a remote **Streamable HTTP** MCP server hosted on Databricks Apps — handling OAuth authentication automatically.
+
+## Installation
+
+```bash
+# Run directly (no install needed)
+uvx uc-mcp-proxy --url https://<workspace>.databricks.com/apps/<app>/mcp
+
+# Or install globally
+uv tool install uc-mcp-proxy
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+### Claude Desktop / Claude Code (`.mcp.json`)
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "unity-catalog": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": [
+        "uc-mcp-proxy",
+        "--url", "https://<workspace>.databricks.com/apps/<app>/mcp"
+      ]
+    }
+  }
+}
+```
+
+### CLI
+
+```bash
+uc-mcp-proxy --url <MCP_SERVER_URL> [--profile <DATABRICKS_PROFILE>] [--auth-type <AUTH_TYPE>]
+```
+
+| Flag | Description |
+|------|-------------|
+| `--url` | **(required)** Remote MCP server URL |
+| `--profile` | Databricks CLI profile name (uses default if omitted) |
+| `--auth-type` | Databricks auth type, e.g. `databricks-cli` |
+
+## How It Works
+
+1. Starts an MCP **stdio** server (stdin/stdout)
+2. Connects to the remote MCP server via **Streamable HTTP**
+3. Injects a fresh Databricks OAuth token on every HTTP request
+4. Bridges messages bidirectionally between the two transports
+
+## OAuth Authentication
+
+Authentication is handled by the [Databricks SDK](https://docs.databricks.com/dev-tools/sdk-python.html), which supports multiple auth methods:
+
+- **Databricks CLI** (`databricks-cli`) — uses tokens from `~/.databrickscfg`
+- **OAuth U2M** — browser-based login flow
+- **PAT** — personal access tokens
+- **Azure / GCP / AWS** — cloud-native identity
+
+The SDK auto-detects the method, or you can force one with `--auth-type`.
+
+## Development
+
+```bash
+uv sync                        # install dependencies
+uv run pytest -m unit -v       # run unit tests
+uv run pytest -m integration -v # run integration tests
+uv build                       # build package
+```
+
+## License
+
+MIT

uc_mcp_proxy-0.1.0/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name = "uc-mcp-proxy"
+version = "0.1.0"
+description = "MCP stdio-to-Streamable-HTTP proxy with Databricks OAuth"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp>=1.8",
+    "databricks-sdk>=0.30.0",
+    "httpx",
+    "anyio",
+]
+license = "MIT"
+readme = "README.md"
+authors = [
+    { name = "Tanner Wendland" },
+]
+keywords = ["mcp", "databricks", "oauth", "proxy", "unity-catalog"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "pytest-randomly>=3.15",
+    "anyio[trio]>=4.0",
+]
+
+[project.scripts]
+uc-mcp-proxy = "uc_mcp_proxy.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/IceRhymers/uc-mcp-proxy"
+Repository = "https://github.com/IceRhymers/uc-mcp-proxy"
+Issues = "https://github.com/IceRhymers/uc-mcp-proxy/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/uc_mcp_proxy"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "unit: Pure unit tests with no external dependencies",
+    "integration: Tests that exercise the full proxy flow with mocked transports",
+]
+addopts = "-v --tb=short --strict-markers"
+pythonpath = ["src"]
+
+[tool.coverage.run]
+source = ["uc_mcp_proxy"]
+branch = true
+omit = ["tests/*"]
+
+[tool.coverage.report]
+show_missing = true
+fail_under = 75
+exclude_lines = [
+    "pragma: no cover",
+    "if __name__ == .__main__.",
+    "if TYPE_CHECKING:",
+]

uc_mcp_proxy-0.1.0/src/uc_mcp_proxy/__init__.py

@@ -0,0 +1,3 @@
+from uc_mcp_proxy.__main__ import DatabricksAuth
+
+__all__ = ["DatabricksAuth"]

uc_mcp_proxy-0.1.0/src/uc_mcp_proxy/__main__.py

@@ -0,0 +1,97 @@
+"""MCP stdio-to-Streamable-HTTP proxy with Databricks OAuth."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+from typing import Generator, AsyncGenerator
+
+import anyio
+import httpx
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from databricks.sdk import WorkspaceClient
+from mcp.client.streamable_http import streamablehttp_client
+from mcp.server.stdio import stdio_server
+
+
+class DatabricksAuth(httpx.Auth):
+    """httpx Auth that injects fresh Databricks OAuth tokens per-request.
+
+    Calls ``WorkspaceClient.config.authenticate()`` on every request to obtain
+    a current OAuth bearer token, ensuring tokens are never stale.
+    """
+
+    def __init__(self, client: WorkspaceClient) -> None:
+        self._client = client
+
+    def _apply_headers(self, request: httpx.Request) -> None:
+        headers = self._client.config.authenticate()
+        request.headers.update(headers)
+        # Also forward the token so the Databricks App can use per-user identity
+        auth_value = headers.get("Authorization", "")
+        if auth_value.startswith("Bearer "):
+            request.headers["X-Forwarded-Access-Token"] = auth_value[len("Bearer "):]
+
+    def sync_auth_flow(self, request: httpx.Request) -> Generator[httpx.Request, httpx.Response, None]:
+        self._apply_headers(request)
+        yield request
+
+    async def async_auth_flow(self, request: httpx.Request) -> AsyncGenerator[httpx.Request, httpx.Response]:
+        self._apply_headers(request)
+        yield request
+
+
+async def copy_stream(source: MemoryObjectReceiveStream, dest: MemoryObjectSendStream) -> None:
+    """Copy all messages from source to dest, closing dest when source is exhausted."""
+    try:
+        async for message in source:
+            await dest.send(message)
+    finally:
+        await dest.aclose()
+
+
+async def bridge(
+    stdio_read: MemoryObjectReceiveStream,
+    stdio_write: MemoryObjectSendStream,
+    http_read: MemoryObjectReceiveStream,
+    http_write: MemoryObjectSendStream,
+) -> None:
+    """Bidirectional bridge between stdio and HTTP stream pairs."""
+    async with anyio.create_task_group() as tg:
+        tg.start_soon(copy_stream, stdio_read, http_write)
+        tg.start_soon(copy_stream, http_read, stdio_write)
+
+
+async def run(url: str, profile: str | None = None, auth_type: str | None = None) -> None:
+    """Run the proxy: bridge stdio transport to Streamable HTTP with Databricks OAuth."""
+    kwargs: dict = {}
+    if profile:
+        kwargs["profile"] = profile
+    if auth_type:
+        kwargs["auth_type"] = auth_type
+    client = WorkspaceClient(**kwargs)
+    auth = DatabricksAuth(client)
+
+    async with stdio_server() as (stdio_read, stdio_write):
+        async with streamablehttp_client(url, auth=auth) as (
+            http_read,
+            http_write,
+            _get_session_id,
+        ):
+            await bridge(stdio_read, stdio_write, http_read, http_write)
+
+
+def main() -> None:
+    """CLI entry point: parse args and run the proxy."""
+    parser = argparse.ArgumentParser(
+        description="MCP stdio-to-Streamable-HTTP proxy with Databricks OAuth",
+    )
+    parser.add_argument("--url", required=True, help="Remote MCP server URL")
+    parser.add_argument("--profile", default=None, help="Databricks CLI profile")
+    parser.add_argument("--auth-type", default=None, help="Databricks auth type (e.g. databricks-cli)")
+    args = parser.parse_args()
+    asyncio.run(run(args.url, args.profile, args.auth_type))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

uc_mcp_proxy-0.1.0/tests/conftest.py

@@ -0,0 +1,165 @@
+"""Shared fixtures for uc-mcp-proxy tests."""
+
+from __future__ import annotations
+
+import pytest
+import httpx
+import anyio
+from contextlib import asynccontextmanager
+from unittest.mock import MagicMock
+
+
+# ---------------------------------------------------------------------------
+# Databricks SDK fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def mock_workspace_client():
+    """Mock WorkspaceClient with OAuth token access.
+
+    Simulates the SDK's authenticate() method which returns
+    fresh auth headers on each call.
+    """
+    client = MagicMock()
+    client.config.host = "https://test-workspace.cloud.databricks.com"
+    client.config.authenticate.return_value = {
+        "Authorization": "Bearer test-oauth-token"
+    }
+    return client
+
+
+# ---------------------------------------------------------------------------
+# Stream fixtures (real anyio memory streams, not mocks)
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def memory_stream_pair():
+    """Factory: create a (send, recv) memory object stream pair.
+
+    Usage:
+        send, recv = memory_stream_pair(buffer=16)
+    """
+    def _make(buffer: int = 16):
+        return anyio.create_memory_object_stream(buffer)
+    return _make
+
+
+@pytest.fixture
+def stdio_streams(memory_stream_pair):
+    """Simulated stdio transport streams.
+
+    Returns (test_send, proxy_read, proxy_write, test_recv):
+    - test_send: test writes here to simulate Claude Code input
+    - proxy_read: proxy reads from here (stdio read side)
+    - proxy_write: proxy writes here (stdio write side)
+    - test_recv: test reads here to verify proxy output to Claude Code
+    """
+    test_send, proxy_read = memory_stream_pair()
+    proxy_write, test_recv = memory_stream_pair()
+    return test_send, proxy_read, proxy_write, test_recv
+
+
+@pytest.fixture
+def http_streams(memory_stream_pair):
+    """Simulated HTTP transport streams.
+
+    Returns (test_send, proxy_read, proxy_write, test_recv):
+    - test_send: test writes here to simulate remote server responses
+    - proxy_read: proxy reads from here (HTTP read side)
+    - proxy_write: proxy writes here (HTTP write side)
+    - test_recv: test reads here to verify proxy sent to remote server
+    """
+    test_send, proxy_read = memory_stream_pair()
+    proxy_write, test_recv = memory_stream_pair()
+    return test_send, proxy_read, proxy_write, test_recv
+
+
+# ---------------------------------------------------------------------------
+# Transport mock fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def mock_stdio_server(stdio_streams):
+    """Async context manager replacing mcp.server.stdio.stdio_server.
+
+    Yields (read_stream, write_stream) from the proxy's perspective.
+    """
+    _, proxy_read, proxy_write, _ = stdio_streams
+
+    @asynccontextmanager
+    async def _mock():
+        yield (proxy_read, proxy_write)
+
+    return _mock
+
+
+@pytest.fixture
+def mock_http_client(http_streams):
+    """Async context manager replacing mcp.client.streamable_http.streamablehttp_client.
+
+    Yields (read_stream, write_stream, get_session_id) from the proxy's perspective.
+    Captures the auth kwarg for auth verification.
+    """
+    _, proxy_read, proxy_write, _ = http_streams
+    captured = {}
+
+    @asynccontextmanager
+    async def _mock(url, *, auth=None, terminate_on_close=True, **kwargs):
+        captured["url"] = url
+        captured["auth"] = auth
+        captured["terminate_on_close"] = terminate_on_close
+        yield (proxy_read, proxy_write, lambda: "mock-session-id")
+
+    _mock.captured = captured
+    return _mock
+
+
+# ---------------------------------------------------------------------------
+# Auth fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def databricks_auth(mock_workspace_client):
+    """Pre-configured DatabricksAuth instance."""
+    from uc_mcp_proxy import DatabricksAuth
+    return DatabricksAuth(mock_workspace_client)
+
+
+# ---------------------------------------------------------------------------
+# Sample message fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def sample_jsonrpc_request():
+    """A sample JSON-RPC request dict (tools/list)."""
+    return {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/list",
+        "params": {},
+    }
+
+
+@pytest.fixture
+def sample_jsonrpc_response():
+    """A sample JSON-RPC response dict (tools/list result)."""
+    return {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "result": {
+            "tools": [
+                {
+                    "name": "chat_postmessage",
+                    "description": "Sends a message to a Slack channel",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "channel": {"type": "string"},
+                            "text": {"type": "string"},
+                        },
+                        "required": ["channel"],
+                    },
+                }
+            ]
+        },
+    }