trackly-mcp-proxy 0.0.1__tar.gz

trackly_mcp_proxy-0.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: trackly-mcp-proxy
+Version: 0.0.1
+Requires-Python: >=3.11
+Requires-Dist: fastmcp==3.4.7
+Requires-Dist: google-auth==2.30.0
+Requires-Dist: google-auth-oauthlib==1.4.1
+Requires-Dist: httpx==0.28.1
+Requires-Dist: requests==2.34.2

trackly_mcp_proxy-0.0.1/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "trackly-mcp-proxy"
+version = "0.0.1"
+requires-python = ">=3.11"
+dependencies = [
+    "fastmcp==3.4.7",
+    "google-auth==2.30.0",
+    "google-auth-oauthlib==1.4.1",
+    "httpx==0.28.1",
+    "requests==2.34.2",
+]
+
+[project.scripts]
+trackly-mcp-proxy = "trackly_mcp_proxy.main:main"

trackly_mcp_proxy-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

trackly_mcp_proxy-0.0.1/trackly_mcp_proxy/__init__.py

@@ -0,0 +1 @@
+"""Local stdio<->HTTP bridge that authenticates analysts to the Trackly MCP server."""

trackly_mcp_proxy-0.0.1/trackly_mcp_proxy/main.py

@@ -0,0 +1,201 @@
+"""Local stdio<->HTTP bridge that obtains the Google ID token Cloud Run IAM demands.
+
+Runs on analyst laptops via `uvx trackly-mcp-proxy --url https://...` and proxies
+an MCP client speaking stdio to the deployed trackly-data-mcp-server over
+Streamable HTTP, attaching a fresh Bearer ID token to every request.
+
+Phase 0 (a) in ARCHITECTURE_PLAN.md Section 9 is settled: a Workspace
+user-account ID token carries this proxy's own OAuth client id as `aud`, and
+the deploy declares that client id as the service's Cloud Run custom audience,
+so token acquisition stays isolated in fetch_id_token() and rollout step 2
+confirms the claims once against the real client.
+"""
+
+import argparse
+import base64
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Callable, Generator
+from urllib.parse import urlsplit
+
+import httpx
+from fastmcp.client import Client
+from fastmcp.client.transports import StreamableHttpTransport
+from fastmcp.server import create_proxy
+from google.auth.exceptions import RefreshError
+from google.auth.transport.requests import Request as GoogleAuthRequest
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+
+OAUTH_CLIENT_ID = os.environ.get("TRACKLY_MCP_OAUTH_CLIENT_ID", "")
+OAUTH_CLIENT_SECRET = os.environ.get("TRACKLY_MCP_OAUTH_CLIENT_SECRET", "")
+OAUTH_SCOPES = ["openid", "email"]
+OAUTH_AUTH_URI = "https://accounts.google.com/o/oauth2/auth"
+OAUTH_TOKEN_URI = "https://oauth2.googleapis.com/token"
+OAUTH_CLIENT_NOT_CONFIGURED_MESSAGE = (
+    "OAuth client not configured — see ARCHITECTURE_PLAN.md §9 Phase 0 (a)"
+)
+OAUTH_CLIENT_NOT_CONFIGURED_EXIT_CODE = 2
+ID_TOKEN_MISSING_MESSAGE = (
+    "No id_token returned for scopes openid,email — the OAuth client cannot "
+    "mint ID tokens; see ARCHITECTURE_PLAN.md §9 Phase 0 (a)"
+)
+
+CREDENTIALS_FILE_MODE = 0o600
+CREDENTIALS_DIR_MODE = 0o700
+
+DEFAULT_MCP_PATH = "/mcp"
+REFRESH_MARGIN_S = 300
+CLIENT_CHOICES = ("claude-desktop", "cursor", "unknown")
+
+
+def parse_args(argv: list[str] | None) -> argparse.Namespace:
+    """Parse the proxy CLI: target MCP server URL and reported client type."""
+    parser = argparse.ArgumentParser(prog="trackly-mcp-proxy")
+    parser.add_argument("--url", required=True, help="Trackly MCP server URL")
+    parser.add_argument(
+        "--client",
+        default="unknown",
+        choices=CLIENT_CHOICES,
+        help="Client identifier sent as X-Trackly-Client for server-side audit",
+    )
+    return parser.parse_args(argv)
+
+
+def normalize_url(url: str) -> str:
+    """Reject non-https URLs, then append /mcp when the URL has no path; FastMCP's
+    http transport mounts there by default and the client transport does not add it."""
+    parsed = urlsplit(url)
+    if parsed.scheme != "https":
+        raise SystemExit("--url must be https")
+    if parsed.path in ("", "/"):
+        return f"{url.rstrip('/')}{DEFAULT_MCP_PATH}"
+    return url
+
+
+def _decode_jwt_exp(token: str) -> float:
+    """Read the `exp` claim from a JWT payload without verifying its signature,
+    used only to schedule refresh of a token this proxy itself just minted."""
+    payload_segment = token.split(".")[1]
+    padded = payload_segment + "=" * (-len(payload_segment) % 4)
+    claims = json.loads(base64.urlsafe_b64decode(padded))
+    return float(claims["exp"])
+
+
+def credentials_path() -> Path:
+    """Cache location for OAuth credentials, resolved at call time from HOME."""
+    return Path.home() / ".config" / "trackly-mcp-proxy" / "credentials.json"
+
+
+def _run_installed_app_flow() -> Credentials:
+    """Launch the browser-based installed-app OAuth flow and return fresh credentials."""
+    client_config = {
+        "installed": {
+            "client_id": OAUTH_CLIENT_ID,
+            "client_secret": OAUTH_CLIENT_SECRET,
+            "auth_uri": OAUTH_AUTH_URI,
+            "token_uri": OAUTH_TOKEN_URI,
+        }
+    }
+    flow = InstalledAppFlow.from_client_config(client_config, scopes=OAUTH_SCOPES)
+    return flow.run_local_server(port=0)
+
+
+def _write_credentials_cache(path: Path, payload: str) -> None:
+    """Write payload with the directory at 0o700 and the file at 0o600, tightening pre-existing modes and refusing a
+    symlink at the cache path where the platform supports it — O_NOFOLLOW and fchmod are Unix-only, so on Windows the
+    write proceeds without those two hardenings instead of raising AttributeError."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.parent.chmod(CREDENTIALS_DIR_MODE)
+    with os.fdopen(
+        os.open(
+            path,
+            os.O_WRONLY | os.O_CREAT | os.O_TRUNC | getattr(os, "O_NOFOLLOW", 0),
+            CREDENTIALS_FILE_MODE,
+        ),
+        "w",
+    ) as cache_file:
+        if hasattr(os, "fchmod"):
+            os.fchmod(cache_file.fileno(), CREDENTIALS_FILE_MODE)
+        cache_file.write(payload)
+
+
+def fetch_id_token() -> tuple[str, float]:
+    """Mint a Google ID token via the installed-app OAuth flow, caching credentials
+    so sign-in happens once (THE Phase 0 (a) function; see module docstring)."""
+    path = credentials_path()
+    credentials = None
+
+    if path.exists():
+        try:
+            credentials = Credentials.from_authorized_user_info(
+                json.loads(path.read_text()), scopes=OAUTH_SCOPES
+            )
+            credentials.refresh(GoogleAuthRequest())
+        except (ValueError, RefreshError):
+            credentials = None
+
+    if credentials is None:
+        credentials = _run_installed_app_flow()
+        credentials.refresh(GoogleAuthRequest())
+
+    _write_credentials_cache(path, credentials.to_json())
+
+    if not credentials.id_token:
+        raise SystemExit(ID_TOKEN_MISSING_MESSAGE)
+
+    return credentials.id_token, _decode_jwt_exp(credentials.id_token)
+
+
+class RefreshingBearerAuth(httpx.Auth):
+    """Bearer auth that refreshes the ID token shortly before it expires;
+    `fetcher`/`clock` default to `fetch_id_token`/`time.time` but are overridable for tests.
+    """
+
+    def __init__(
+        self,
+        token: str,
+        exp: float,
+        fetcher: Callable[[], tuple[str, float]] = fetch_id_token,
+        clock: Callable[[], float] = time.time,
+    ) -> None:
+        """Store the initial token/expiry and the fetcher/clock used to refresh them."""
+        self._token = token
+        self._exp = exp
+        self._fetcher = fetcher
+        self._clock = clock
+
+    def auth_flow(
+        self, request: httpx.Request
+    ) -> Generator[httpx.Request, httpx.Response, None]:
+        """Refresh the cached token when within REFRESH_MARGIN_S of expiry, then attach it."""
+        if self._clock() >= self._exp - REFRESH_MARGIN_S:
+            self._token, self._exp = self._fetcher()
+        request.headers["Authorization"] = f"Bearer {self._token}"
+        yield request
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Mint an ID token, then bridge stdio to the Trackly MCP server over HTTP via create_proxy (FastMCP.as_proxy is deprecated in 3.4.7)."""
+    if not OAUTH_CLIENT_ID or not OAUTH_CLIENT_SECRET:
+        print(OAUTH_CLIENT_NOT_CONFIGURED_MESSAGE, file=sys.stderr)
+        return OAUTH_CLIENT_NOT_CONFIGURED_EXIT_CODE
+
+    args = parse_args(argv)
+    token, exp = fetch_id_token()
+
+    transport = StreamableHttpTransport(
+        normalize_url(args.url),
+        auth=RefreshingBearerAuth(token, exp),
+        headers={"X-Trackly-Client": args.client},
+    )
+    client = Client(transport)
+    create_proxy(client).run("stdio")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

trackly_mcp_proxy-0.0.1/trackly_mcp_proxy.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: trackly-mcp-proxy
+Version: 0.0.1
+Requires-Python: >=3.11
+Requires-Dist: fastmcp==3.4.7
+Requires-Dist: google-auth==2.30.0
+Requires-Dist: google-auth-oauthlib==1.4.1
+Requires-Dist: httpx==0.28.1
+Requires-Dist: requests==2.34.2

trackly_mcp_proxy-0.0.1/trackly_mcp_proxy.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+pyproject.toml
+trackly_mcp_proxy/__init__.py
+trackly_mcp_proxy/main.py
+trackly_mcp_proxy.egg-info/PKG-INFO
+trackly_mcp_proxy.egg-info/SOURCES.txt
+trackly_mcp_proxy.egg-info/dependency_links.txt
+trackly_mcp_proxy.egg-info/entry_points.txt
+trackly_mcp_proxy.egg-info/requires.txt
+trackly_mcp_proxy.egg-info/top_level.txt

trackly_mcp_proxy-0.0.1/trackly_mcp_proxy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

trackly_mcp_proxy-0.0.1/trackly_mcp_proxy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+trackly-mcp-proxy = trackly_mcp_proxy.main:main

trackly_mcp_proxy-0.0.1/trackly_mcp_proxy.egg-info/requires.txt

@@ -0,0 +1,5 @@
+fastmcp==3.4.7
+google-auth==2.30.0
+google-auth-oauthlib==1.4.1
+httpx==0.28.1
+requests==2.34.2

trackly_mcp_proxy-0.0.1/trackly_mcp_proxy.egg-info/top_level.txt

@@ -0,0 +1 @@
+trackly_mcp_proxy