mtrx-cli 0.1.25 → 0.1.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtrx-cli",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "MATRX CLI for routing Codex, Claude, and Cursor through Matrx",
   "homepage": "https://mtrx.so",
   "repository": {

package/src/matrx/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.25"
+__version__ = "0.1.26"

package/src/matrx/cli/cursor_ca.py

@@ -12,14 +12,16 @@ import datetime
 import logging
 import os
 import platform
+import ssl
 import subprocess
 import threading
+from dataclasses import dataclass
 from pathlib import Path
 
 from cryptography import x509
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
-from cryptography.x509.oid import NameOID
+from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID
 
 from matrx.cli.state import config_dir
 
@@ -30,6 +32,24 @@ _CA_KEY_FILE = "mtrx-ca.key"
 _CA_CERT_FILE = "mtrx-ca.pem"
 _CERT_VALIDITY_YEARS = 5
 _LEAF_VALIDITY_DAYS = 365
+_CA_COMMON_NAME = "MTRX Cursor Proxy CA"
+_CA_ORGANIZATION = "MTRX"
+_WINDOWS_ROOT_USER = "CurrentUser\\Root"
+_WINDOWS_ROOT_MACHINE = "LocalMachine\\Root"
+
+
+@dataclass(frozen=True)
+class HostCertMaterial:
+    hostname: str
+    cert_pem: bytes
+    key_pem: bytes
+    cert_path: Path
+    key_path: Path
+    leaf_serial: str
+    leaf_sha256: str
+    ca_sha256: str
+    chain_length: int
+    ssl_context: ssl.SSLContext
 
 
 def ca_dir() -> Path:
@@ -63,8 +83,8 @@ def generate_ca(*, force: bool = False) -> tuple[Path, Path]:
 
     key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
     subject = issuer = x509.Name([
-        x509.NameAttribute(NameOID.ORGANIZATION_NAME, "MTRX"),
-        x509.NameAttribute(NameOID.COMMON_NAME, "MTRX Cursor Proxy CA"),
+        x509.NameAttribute(NameOID.ORGANIZATION_NAME, _CA_ORGANIZATION),
+        x509.NameAttribute(NameOID.COMMON_NAME, _CA_COMMON_NAME),
     ])
     now = datetime.datetime.now(datetime.timezone.utc)
     cert = (
@@ -75,7 +95,11 @@ def generate_ca(*, force: bool = False) -> tuple[Path, Path]:
         .serial_number(x509.random_serial_number())
         .not_valid_before(now)
         .not_valid_after(now + datetime.timedelta(days=_CERT_VALIDITY_YEARS * 365))
-        .add_extension(x509.BasicConstraints(ca=True, path_length=0), critical=True)
+        .add_extension(x509.BasicConstraints(ca=True, path_length=None), critical=True)
+        .add_extension(
+            x509.SubjectKeyIdentifier.from_public_key(key.public_key()),
+            critical=False,
+        )
         .add_extension(
             x509.KeyUsage(
                 digital_signature=True,
@@ -127,48 +151,76 @@ class CertCache:
         self._ca_key = ca_key
         self._ca_cert = ca_cert
         self._lock = threading.Lock()
-        self._cache: dict[str, tuple[bytes, bytes]] = {}
-        self._ctx_cache: dict[str, "ssl.SSLContext"] = {}
+        self._cache: dict[str, HostCertMaterial] = {}
         self._certs_dir = ca_dir() / "certs"
         self._certs_dir.mkdir(parents=True, exist_ok=True)
 
     def get_cert_pair(self, hostname: str) -> tuple[bytes, bytes]:
         """Return (cert_pem, key_pem) for *hostname*, creating if needed."""
-        with self._lock:
-            if hostname in self._cache:
-                return self._cache[hostname]
-
-        cert_pem, key_pem = self._sign_leaf(hostname)
-
-        with self._lock:
-            self._cache[hostname] = (cert_pem, key_pem)
-        return cert_pem, key_pem
+        material = self.get_or_create_material(hostname)
+        return material.cert_pem, material.key_pem
 
     def get_ssl_context(self, hostname: str) -> "ssl.SSLContext":
         """Return a server-side ``ssl.SSLContext`` for *hostname*."""
-        import ssl as _ssl
-
+        return self.get_or_create_material(hostname).ssl_context
+
+    def get_handshake_info(self, hostname: str) -> dict[str, str | int | bool]:
+        material = self.get_or_create_material(hostname)
+        return {
+            "hostname": hostname,
+            "leaf_serial": material.leaf_serial,
+            "leaf_sha256": material.leaf_sha256,
+            "ca_sha256": material.ca_sha256,
+            "chain_length": material.chain_length,
+            "cert_path": str(material.cert_path),
+            "key_path": str(material.key_path),
+            "cache_ready": True,
+        }
+
+    def prewarm(self, hostnames: list[str] | tuple[str, ...]) -> None:
+        for hostname in hostnames:
+            self.get_or_create_material(hostname)
+
+    def get_or_create_material(self, hostname: str) -> HostCertMaterial:
         with self._lock:
-            if hostname in self._ctx_cache:
-                return self._ctx_cache[hostname]
+            material = self._cache.get(hostname)
+            if material is not None:
+                return material
 
-        cert_pem, key_pem = self.get_cert_pair(hostname)
+            material = self._build_material(hostname)
+            self._cache[hostname] = material
+            return material
 
+    def _build_material(self, hostname: str) -> HostCertMaterial:
+        cert_pem, key_pem, leaf_cert = self._sign_leaf(hostname)
         cert_file = self._certs_dir / f"{hostname}.crt"
         key_file = self._certs_dir / f"{hostname}.key"
         cert_file.write_bytes(cert_pem)
         key_file.write_bytes(key_pem)
         os.chmod(key_file, 0o600)
 
-        ctx = _ssl.SSLContext(_ssl.PROTOCOL_TLS_SERVER)
+        chain = self._pem_certificates(cert_pem)
+        if len(chain) < 2:
+            raise ValueError(f"incomplete served certificate chain for {hostname}")
+
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
         ctx.load_cert_chain(str(cert_file), str(key_file))
         ctx.set_alpn_protocols(["http/1.1"])
 
-        with self._lock:
-            self._ctx_cache[hostname] = ctx
-        return ctx
+        return HostCertMaterial(
+            hostname=hostname,
+            cert_pem=cert_pem,
+            key_pem=key_pem,
+            cert_path=cert_file,
+            key_path=key_file,
+            leaf_serial=f"{leaf_cert.serial_number:X}",
+            leaf_sha256=leaf_cert.fingerprint(hashes.SHA256()).hex(),
+            ca_sha256=self._ca_cert.fingerprint(hashes.SHA256()).hex(),
+            chain_length=len(chain),
+            ssl_context=ctx,
+        )
 
-    def _sign_leaf(self, hostname: str) -> tuple[bytes, bytes]:
+    def _sign_leaf(self, hostname: str) -> tuple[bytes, bytes, x509.Certificate]:
         leaf_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
         now = datetime.datetime.now(datetime.timezone.utc)
         subject = x509.Name([
@@ -182,7 +234,7 @@ class CertCache:
             .public_key(leaf_key.public_key())
             .serial_number(x509.random_serial_number())
             .not_valid_before(now - datetime.timedelta(days=1))
-            .not_valid_after(now + datetime.timedelta(days=_LEAF_VALIDITY_DAYS))
+            .not_valid_after(now + datetime.timedelta(days=min(_LEAF_VALIDITY_DAYS, 397)))
             .add_extension(
                 x509.SubjectAlternativeName([x509.DNSName(hostname)]),
                 critical=False,
@@ -191,16 +243,55 @@ class CertCache:
                 x509.BasicConstraints(ca=False, path_length=None),
                 critical=True,
             )
+            .add_extension(
+                x509.KeyUsage(
+                    digital_signature=True,
+                    key_encipherment=True,
+                    key_cert_sign=False,
+                    crl_sign=False,
+                    content_commitment=False,
+                    data_encipherment=False,
+                    key_agreement=False,
+                    encipher_only=False,
+                    decipher_only=False,
+                ),
+                critical=True,
+            )
+            .add_extension(
+                x509.ExtendedKeyUsage([ExtendedKeyUsageOID.SERVER_AUTH]),
+                critical=False,
+            )
+            .add_extension(
+                x509.SubjectKeyIdentifier.from_public_key(leaf_key.public_key()),
+                critical=False,
+            )
+            .add_extension(
+                x509.AuthorityKeyIdentifier.from_issuer_public_key(self._ca_key.public_key()),
+                critical=False,
+            )
         )
         leaf_cert = builder.sign(self._ca_key, hashes.SHA256())
 
-        cert_pem = leaf_cert.public_bytes(serialization.Encoding.PEM)
+        cert_pem = (
+            leaf_cert.public_bytes(serialization.Encoding.PEM)
+            + self._ca_cert.public_bytes(serialization.Encoding.PEM)
+        )
         key_pem = leaf_key.private_bytes(
             encoding=serialization.Encoding.PEM,
             format=serialization.PrivateFormat.TraditionalOpenSSL,
             encryption_algorithm=serialization.NoEncryption(),
         )
-        return cert_pem, key_pem
+        return cert_pem, key_pem, leaf_cert
+
+    @staticmethod
+    def _pem_certificates(pem_bytes: bytes) -> list[bytes]:
+        marker = b"-----END CERTIFICATE-----"
+        certs: list[bytes] = []
+        for part in pem_bytes.split(marker):
+            if b"-----BEGIN CERTIFICATE-----" not in part:
+                continue
+            certs.append(part + marker + b"\n")
+        return certs
 
 
 # ---------------------------------------------------------------------------
@@ -249,14 +340,71 @@ def _trust_ca_linux(cert_path: Path) -> bool:
 
 
 def _trust_ca_windows(cert_path: Path) -> bool:
-    result = subprocess.run(
-        ["certutil", "-addstore", "Root", str(cert_path)],
-        capture_output=True,
-        timeout=30,
-    )
+    status = windows_trust_status(cert_path)
+    if status["fully_trusted"]:
+        return True
+
+    user_ok = status["user_root"] or _add_ca_to_windows_store(cert_path, user=True)
+    machine_ok = status["machine_root"]
+    if not machine_ok:
+        machine_ok = _add_ca_to_windows_store(cert_path, user=False)
+    return user_ok or machine_ok
+
+
+def _cert_subject_and_fingerprint(cert_path: Path) -> tuple[str, str] | None:
+    try:
+        cert = x509.load_pem_x509_certificate(cert_path.read_bytes())
+    except (OSError, ValueError):
+        return None
+    return cert.subject.rfc4514_string(), cert.fingerprint(hashes.SHA1()).hex().upper()
+
+
+def _certutil_store_output(*, user: bool) -> str:
+    command = ["certutil"]
+    if user:
+        command.append("-user")
+    command.extend(["-store", "Root"])
+    try:
+        result = subprocess.run(command, capture_output=True, timeout=15)
+    except Exception:
+        return ""
+    if result.returncode != 0:
+        return ""
+    return result.stdout.decode("utf-8", errors="replace").upper()
+
+
+def _is_ca_trusted_windows(cert_path: Path, *, user: bool) -> bool:
+    cert_info = _cert_subject_and_fingerprint(cert_path)
+    if cert_info is None:
+        return False
+    subject, fingerprint = cert_info
+    output = _certutil_store_output(user=user)
+    return fingerprint in output or subject.upper() in output
+
+
+def _add_ca_to_windows_store(cert_path: Path, *, user: bool) -> bool:
+    command = ["certutil"]
+    if user:
+        command.append("-user")
+    command.extend(["-addstore", "Root", str(cert_path)])
+    try:
+        result = subprocess.run(command, capture_output=True, timeout=30)
+    except Exception:
+        return False
     return result.returncode == 0
 
 
+def windows_trust_status(cert_path: Path | None = None) -> dict[str, bool]:
+    cert_path = cert_path or ca_cert_path()
+    user_root = _is_ca_trusted_windows(cert_path, user=True)
+    machine_root = _is_ca_trusted_windows(cert_path, user=False)
+    return {
+        "user_root": user_root,
+        "machine_root": machine_root,
+        "fully_trusted": user_root and machine_root,
+    }
+
+
 def is_ca_trusted() -> bool:
     """Best-effort check whether the MTRX CA is trusted by the OS."""
     if not ca_exists():
@@ -265,11 +413,13 @@ def is_ca_trusted() -> bool:
     try:
         if system == "Darwin":
             result = subprocess.run(
-                ["security", "find-certificate", "-c", "MTRX Cursor Proxy CA"],
+                ["security", "find-certificate", "-c", _CA_COMMON_NAME],
                 capture_output=True,
                 timeout=10,
             )
             return result.returncode == 0
+        if system == "Windows":
+            return windows_trust_status(ca_cert_path())["fully_trusted"]
     except Exception:
         pass
     return False

package/src/matrx/cli/cursor_config.py

@@ -475,6 +475,8 @@ def configure_cursor_proxy_settings(
     # Inject NODE_EXTRA_CA_CERTS into integrated terminal env so Cursor's
     # Node.js runtime trusts our CA.  Cursor itself reads this from the
     # process environment, but setting it here covers more cases.
+    # Explicitly unset HTTPS_PROXY/HTTP_PROXY in terminals so child processes
+    # (e.g. Claude Code) do NOT inherit the proxy from the Cursor process.
     for env_key in (
         "terminal.integrated.env.osx",
         "terminal.integrated.env.linux",
@@ -484,6 +486,11 @@ def configure_cursor_proxy_settings(
         if not isinstance(env_block, dict):
             env_block = {}
         env_block["NODE_EXTRA_CA_CERTS"] = ca_cert_path
+        # null unsets an inherited env var in VS Code integrated terminals
+        env_block["HTTPS_PROXY"] = None
+        env_block["HTTP_PROXY"] = None
+        env_block["https_proxy"] = None
+        env_block["http_proxy"] = None
         settings[env_key] = env_block
 
     _write_settings_json(settings)
@@ -511,6 +518,8 @@ def restore_cursor_proxy_settings(previous: dict) -> bool:
             env_block = settings.get(env_key)
             if isinstance(env_block, dict):
                 env_block.pop("NODE_EXTRA_CA_CERTS", None)
+                for _k in ("HTTPS_PROXY", "HTTP_PROXY", "https_proxy", "http_proxy"):
+                    env_block.pop(_k, None)
                 if not env_block:
                     settings.pop(env_key, None)
         else:

package/src/matrx/cli/cursor_launcher.py

@@ -85,14 +85,16 @@ def launch_cursor_with_proxy(
     env["HTTP_PROXY"] = proxy_url
     env["HTTPS_PROXY"] = proxy_url
     env["NODE_EXTRA_CA_CERTS"] = str(ca_cert_path)
+    launch_args = [exe]
 
     kwargs: dict = {}
     if platform.system() == "Windows":
         kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS
+        launch_args.append("--disable-quic")
 
     try:
         subprocess.Popen(
-            [exe],
+            launch_args,
             env=env,
             stdin=subprocess.DEVNULL,
             stdout=subprocess.DEVNULL,