sproxy 0.1.0__py3-none-any.whl

sproxy/__init__.py

@@ -0,0 +1,8 @@
+"""sproxy - local egress guard for coding agents.
+
+Keep this module import-light: it is imported both by the CLI (user's Python)
+and by the mitmproxy addon (mitmdump's bundled interpreter). Only the standard
+library may be imported at package import time.
+"""
+
+__version__ = "0.1.0"

sproxy/__main__.py

@@ -0,0 +1,4 @@
+from sproxy.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sproxy/addon.py

@@ -0,0 +1,468 @@
+"""mitmproxy addon: the egress guard.
+
+Loaded by ``mitmdump -s`` inside mitmproxy's bundled interpreter. It reads a
+*resolved* policy (secret values already filled in by the trusted CLI) from the
+file named in ``SPROXY_POLICY`` and adds ``SPROXY_PKG`` to ``sys.path`` so it can
+import the pure-Python ``sproxy`` modules.
+
+Per request it:
+  1. injects secrets into requests bound for hosts they're allowed to reach,
+  2. blocks/redacts/warns when a known secret heads to a host it may not,
+  3. runs credential pattern detection (warn/discovery),
+  4. records every request in the tamper-evident audit log.
+
+The resolved policy is re-read when the CLI rewrites it (a hot reload of the
+user's policy file). All of the rules live in one immutable :class:`_State`
+object that a reload swaps in wholesale, and each request reads that object
+once, so traffic is never guarded by a half-applied policy.
+
+Everything runs under a broad try/except: a bug in the guard must never take
+down the user's agent session, so on error we log and let traffic through.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from urllib.parse import urlsplit
+
+# How often to check the resolved policy file for a rewrite by the CLI.
+POLICY_POLL_SECONDS = 1.0
+
+# Make the installed sproxy package importable inside mitmdump's interpreter.
+_pkg = os.environ.get("SPROXY_PKG")
+if _pkg and _pkg not in sys.path:
+    sys.path.insert(0, _pkg)
+
+from mitmproxy import http  # noqa: E402  (only available inside mitmdump)
+
+from sproxy import policy as _policy  # noqa: E402
+from sproxy.audit import AuditLog  # noqa: E402
+from sproxy.auth import decode_basic_authorization, inject_basic_placeholder  # noqa: E402
+from sproxy.replacements import (  # noqa: E402
+    has_session_token,
+    replacement_tokens,
+    replace_request_tokens,
+)
+from sproxy.scanner import Scanner  # noqa: E402
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _file_stamp(path: str) -> tuple[int, int] | None:
+    """Cheap change detector: (mtime_ns, size), or None when unreadable."""
+    if not path:
+        return None
+    try:
+        st = os.stat(path)
+    except OSError:
+        return None
+    return st.st_mtime_ns, st.st_size
+
+
+class _Secret:
+    __slots__ = ("name", "value", "allow_hosts", "session_token", "anywhere")
+
+    def __init__(
+        self,
+        name: str,
+        value: str,
+        allow_hosts: list[str],
+        session_token: str = "",
+        anywhere: bool = False,
+    ):
+        self.name = name
+        self.value = value
+        self.allow_hosts = allow_hosts
+        self.session_token = session_token
+        self.anywhere = anywhere
+
+    def allowed_to(self, host: str) -> bool:
+        return self.anywhere or _policy.host_matches(host, self.allow_hosts)
+
+
+class _State:
+    """One immutable snapshot of the rules: everything a reload can change."""
+
+    __slots__ = (
+        "mode", "on_leak", "detect_patterns",
+        "passthrough_hosts", "secrets", "values", "scanner",
+        "managed", "watched", "revoked",
+    )
+
+    def __init__(self, resolved: dict):
+        self.mode = resolved.get("mode", _policy.MODE_MONITOR)
+        self.on_leak = resolved.get("on_leak", _policy.ON_LEAK_BLOCK)
+        self.detect_patterns = bool(resolved.get("detect_patterns", True))
+        # Hosts to tunnel WITHOUT TLS interception (e.g. certificate pinning).
+        # sproxy cannot see inside these connections - they are audited as
+        # uninspected.
+        self.passthrough_hosts = resolved.get("passthrough_hosts", [])
+
+        self.secrets = [
+            _Secret(
+                s["name"],
+                s["value"],
+                s.get("allow_hosts", []),
+                s.get("session_token", ""),
+                anywhere=not s.get("allow_hosts"),
+            )
+            for s in resolved.get("secrets", [])
+            if s.get("value")
+        ]
+        self.managed = len(self.secrets)
+        # watch_values are secrets that may go nowhere: any appearance is a leak.
+        for i, v in enumerate(resolved.get("watch_values", [])):
+            if v:
+                self.secrets.append(_Secret(f"watch_{i}", v, []))
+        self.watched = len(self.secrets) - self.managed
+        # Handles for secrets a reload dropped from the policy. The guarded
+        # process still holds them in its environment, so they must keep being
+        # recognised - but they now unlock nothing and may go nowhere.
+        self.revoked = 0
+        for handle in resolved.get("revoked_handles", []):
+            token = handle.get("session_token")
+            if token:
+                self.secrets.append(
+                    _Secret(f"revoked:{handle.get('name', '?')}", "", [], token)
+                )
+                self.revoked += 1
+
+        self.values = {s.name: s.value for s in self.secrets}
+        self.scanner = Scanner(detect_patterns=self.detect_patterns)
+
+    def summary(self) -> str:
+        parts = [
+            f"mode={self.mode}",
+            f"on_leak={self.on_leak}",
+            f"secrets={self.managed}",
+        ]
+        if self.watched:
+            parts.append(f"watched={self.watched}")
+        if self.revoked:
+            parts.append(f"revoked={self.revoked}")
+        return " ".join(parts)
+
+
+class EgressGuard:
+    def __init__(self, resolved: dict, policy_path: str = ""):
+        self._state = _State(resolved)
+        self._policy_path = policy_path
+        self._stamp = _file_stamp(policy_path)
+        self._poller: asyncio.Task | None = None
+
+        self._audit_path = resolved.get("audit_log") or ""
+        self.audit = AuditLog(self._audit_path) if self._audit_path else None
+
+    # -- reload ----------------------------------------------------------
+
+    def running(self) -> None:
+        """mitmproxy lifecycle hook: start watching the resolved policy file."""
+        if not self._policy_path or self._poller is not None:
+            return
+        try:
+            self._poller = asyncio.ensure_future(self._poll_policy())
+        except RuntimeError:  # no event loop (unit tests)
+            self._poller = None
+
+    def done(self) -> None:
+        if self._poller is not None:
+            self._poller.cancel()
+            self._poller = None
+
+    async def _poll_policy(self) -> None:
+        """Poll rather than watch: the file lives in a private temp dir that may
+        sit on a filesystem inotify does not report (containers, tmpfs mounts)."""
+        while True:
+            await asyncio.sleep(POLICY_POLL_SECONDS)
+            try:
+                self.maybe_reload()
+            except Exception as exc:  # never let the watcher die
+                print(f"sproxy: policy poll error: {exc}", file=sys.stderr, flush=True)
+
+    def maybe_reload(self) -> bool:
+        """Swap in a rewritten policy file. True when new rules took effect."""
+        stamp = _file_stamp(self._policy_path)
+        if stamp is None or stamp == self._stamp:
+            return False
+        # Record the stamp either way: a file we cannot use must not be
+        # retried (and re-logged) on every poll.
+        self._stamp = stamp
+        try:
+            with open(self._policy_path, encoding="utf-8") as fh:
+                resolved = json.load(fh)
+            state = _State(resolved)
+        except Exception as exc:
+            print(
+                f"sproxy: ignoring unreadable policy update, keeping the "
+                f"previous rules: {exc}",
+                file=sys.stderr,
+                flush=True,
+            )
+            return False
+        audit_path = resolved.get("audit_log") or ""
+        if audit_path != self._audit_path:
+            try:
+                self.audit = AuditLog(audit_path) if audit_path else None
+                self._audit_path = audit_path
+            except OSError as exc:
+                print(f"sproxy: keeping the previous audit log: {exc}",
+                      file=sys.stderr, flush=True)
+        # One rebind, so a request in flight keeps the rules it started with.
+        self._state = state
+        print(f"sproxy: rules reloaded ({state.summary()})", file=sys.stderr, flush=True)
+        return True
+
+    # -- helpers ---------------------------------------------------------
+
+    def _enforcing(self, state: _State) -> bool:
+        return state.mode == _policy.MODE_ENFORCE
+
+    def _safe_path(self, url: str, state: _State | None = None) -> str:
+        state = self._state if state is None else state
+        try:
+            path = urlsplit(url).path
+            for s in state.secrets:
+                for value in (s.value, s.session_token):
+                    if value:
+                        path = path.replace(value, f"[sproxy:redacted:{s.name}]")
+            return path
+        except Exception:
+            return ""
+
+    def _emit(self, *, decision: str, method: str, host: str, path: str = "",
+              scheme: str = "https", nbytes: int = 0, rules: list[str] | None = None,
+              mode: str = "") -> None:
+        rules = rules or []
+        line = f"sproxy: {decision.upper():11} {method} {host}{path}"
+        if rules:
+            line += f"  [{', '.join(rules)}]"
+        print(line, file=sys.stderr, flush=True)
+        if self.audit is None:
+            return
+        try:
+            self.audit.append(
+                {
+                    "ts": _now(),
+                    "mode": mode or self._state.mode,
+                    "method": method,
+                    "scheme": scheme,
+                    "host": host,
+                    "path": path,
+                    "bytes": nbytes,
+                    "decision": decision,
+                    "rules": rules,
+                }
+            )
+        except Exception as exc:  # never let audit failure break traffic
+            print(f"sproxy: audit write failed: {exc}", file=sys.stderr, flush=True)
+
+    def _log(self, flow: http.HTTPFlow, decision: str, rules: list[str],
+             state: _State | None = None, path: str | None = None) -> None:
+        state = self._state if state is None else state
+        req = flow.request
+        self._emit(
+            decision=decision, method=req.method, host=req.pretty_host,
+            path=self._safe_path(req.pretty_url, state) if path is None else path,
+            scheme=req.scheme,
+            nbytes=len(req.raw_content or b""), rules=rules, mode=state.mode,
+        )
+
+    def _block(self, flow: http.HTTPFlow, reason: str, rules: list[str],
+               state: _State | None = None, path: str | None = None) -> None:
+        """Refuse the request with 407 Proxy Authentication Required.
+        """
+        payload = json.dumps(
+            {"error": "blocked_by_sproxy", "reason": reason, "rules": rules}
+        )
+        # RFC 9110 requires a challenge on a 407. The scheme is deliberately one
+        # no client can satisfy: the request is refused, not retryable with
+        # credentials. It also carries the reason for clients that only surface
+        # headers.
+        quoted = reason.replace('"', "'")
+        challenge = f'SProxy realm="sproxy", reason="{quoted}"'
+        flow.response = http.Response.make(
+            407,
+            payload.encode(),
+            {
+                "content-type": "application/json",
+                "x-sproxy": "blocked",
+                "proxy-authenticate": challenge,
+            },
+        )
+        self._log(flow, "blocked", rules, state, path)
+
+    # -- injection -------------------------------------------------------
+
+    def _inject(self, flow: http.HTTPFlow, host: str,
+                state: _State | None = None) -> None:
+        state = self._state if state is None else state
+        req = flow.request
+        for s in state.secrets:
+            if not s.value or not s.allowed_to(host):
+                continue
+            tokens = replacement_tokens(s.name, s.session_token)
+
+            for key, val in list(req.headers.items()):
+                val = replace_request_tokens(val, s.name, s.value, s.session_token)
+                for token in tokens:
+                    # curl's --user option sends a placeholder as a
+                    # Base64-encoded HTTP Basic Authorization header.
+                    val = inject_basic_placeholder(val, token, s.value)
+                req.headers[key] = val
+            # POC-compatible: a header literally named after the secret.
+            if s.name in req.headers:
+                req.headers[s.name] = s.value
+
+            for key, val in list(req.query.items()):
+                req.query[key] = replace_request_tokens(
+                    val, s.name, s.value, s.session_token
+                )
+            if s.name in req.query:
+                req.query[s.name] = s.value
+
+            text = req.get_text(strict=False)
+            if text:
+                req.set_text(
+                    replace_request_tokens(text, s.name, s.value, s.session_token)
+                )
+
+    # -- egress scanning -------------------------------------------------
+
+    def _surface(self, flow: http.HTTPFlow) -> str:
+        req = flow.request
+        parts = [req.pretty_url]
+        for _, val in req.headers.items():
+            parts.append(val)
+            # Include Basic credentials in the scan. This preserves the
+            # per-secret host guard even when a client has Base64-encoded them.
+            credentials = decode_basic_authorization(val)
+            if credentials is not None:
+                parts.append(credentials)
+        text = req.get_text(strict=False)
+        if text:
+            parts.append(text)
+        return "\n".join(parts)
+
+    def _leaked_secrets(self, surface: str, host: str,
+                        state: _State | None = None) -> list[str]:
+        """Secret values or session handles bound for the wrong host."""
+        state = self._state if state is None else state
+        leaked = []
+        for s in state.secrets:
+            secret_present = s.value and s.value in surface
+            handle_present = has_session_token(surface, s.session_token)
+            if (secret_present or handle_present) and not s.allowed_to(host):
+                leaked.append(s.name)
+        return leaked
+
+    def _pattern_findings(self, surface: str,
+                          state: _State | None = None) -> list[str]:
+        state = self._state if state is None else state
+        # Remove known secret values first so injected/known secrets aren't
+        # double-reported as generic pattern hits.
+        cleaned = surface
+        for v in state.values.values():
+            if v:
+                cleaned = cleaned.replace(v, "")
+        for s in state.secrets:
+            if s.session_token:
+                cleaned = cleaned.replace(s.session_token, "")
+        return [f"pattern:{f.name}" for f in state.scanner.scan(cleaned) if f.kind == "pattern"]
+
+    def _redact(self, flow: http.HTTPFlow, names: list[str],
+                state: _State | None = None) -> None:
+        state = self._state if state is None else state
+        wanted = {
+            s.name: tuple(value for value in (s.value, s.session_token) if value)
+            for s in state.secrets
+            if s.name in names
+        }
+        marker = lambda n: f"[sproxy:redacted:{n}]"  # noqa: E731
+        req = flow.request
+
+        def scrub(text: str) -> str:
+            for n, values in wanted.items():
+                for value in values:
+                    if value in text:
+                        text = text.replace(value, marker(n))
+            return text
+
+        for key, val in list(req.headers.items()):
+            req.headers[key] = scrub(val)
+        for key, val in list(req.query.items()):
+            req.query[key] = scrub(val)
+        text = req.get_text(strict=False)
+        if text:
+            req.set_text(scrub(text))
+
+    # -- mitmproxy hooks -------------------------------------------------
+
+    def tls_clienthello(self, data) -> None:
+        """Tunnel configured hosts without interception (for pinned clients).
+
+        The connection is allowed, but its contents cannot be inspected, so we
+        record it as uninspected rather than pretend it was guarded.
+        """
+        try:
+            sni = getattr(getattr(data, "client_hello", None), "sni", None) or ""
+            if sni and _policy.host_matches(sni, self._state.passthrough_hosts):
+                data.ignore_connection = True
+                self._emit(decision="passthrough", method="CONNECT", host=sni,
+                           rules=["tls:uninspected"])
+        except Exception as exc:  # fail open
+            print(f"sproxy: tls_clienthello error: {exc}", file=sys.stderr, flush=True)
+
+    def request(self, flow: http.HTTPFlow) -> None:
+        try:
+            self._handle(flow)
+        except Exception as exc:  # fail open: never break the agent's session
+            print(f"sproxy: internal error, allowing request: {exc}", file=sys.stderr, flush=True)
+
+    def _handle(self, flow: http.HTTPFlow) -> None:
+        # Take the rules once: a policy reload landing mid-request must not
+        # inject under one policy and then judge the result under another.
+        state = self._state
+        host = flow.request.pretty_host
+
+        # 1. Inject secrets destined for hosts that are allowed to receive them.
+        self._inject(flow, host, state)
+
+        # 2+3. Scan the (post-injection) request for leaks and credential shapes.
+        surface = self._surface(flow)
+        leaked = self._leaked_secrets(surface, host, state)
+        patterns = self._pattern_findings(surface, state)
+        rules = [f"secret:{n}" for n in leaked] + patterns
+
+        # 4. Decide.
+        if leaked and self._enforcing(state):
+            if state.on_leak == _policy.ON_LEAK_BLOCK:
+                self._block(
+                    flow, f"secret(s) {leaked} not allowed to {host}", rules, state
+                )
+                return
+            if state.on_leak == _policy.ON_LEAK_REDACT:
+                self._redact(flow, leaked, state)
+                self._log(flow, "redacted", rules, state)
+                return
+            # on_leak == warn falls through to allow-with-warning.
+
+        decision = "warn" if rules else "allow"
+        self._log(flow, decision, rules, state)
+
+
+def _load_guard() -> EgressGuard:
+    path = os.environ.get("SPROXY_POLICY")
+    if not path:
+        print("sproxy: SPROXY_POLICY not set; running in pass-through monitor mode", file=sys.stderr)
+        return EgressGuard({"mode": _policy.MODE_MONITOR, "detect_patterns": True})
+    with open(path, encoding="utf-8") as fh:
+        return EgressGuard(json.load(fh), policy_path=path)
+
+
+addons = [_load_guard()]

sproxy/audit.py

@@ -0,0 +1,88 @@
+"""Tamper-evident JSONL audit log.
+
+Each line is one request decision. Lines are chained: every entry stores the
+SHA-256 of the previous entry, and its own hash covers that link plus all its
+own fields. Deleting, reordering, or editing any line breaks the chain from
+that point on, which ``verify`` detects. This is the artifact a security team
+wants after an incident: a log that can't be quietly doctored.
+
+Secret *values* are never written here - only rule names (see scanner.Finding).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+GENESIS = "0" * 64
+
+
+def _canonical(entry: dict) -> str:
+    return json.dumps(entry, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+
+
+def _hash(prev: str, core: dict) -> str:
+    return hashlib.sha256((prev + _canonical(core)).encode("utf-8")).hexdigest()
+
+
+class AuditLog:
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+        self._seq, self._prev = self._resume()
+
+    def _resume(self) -> tuple[int, str]:
+        """Continue an existing chain, or start a fresh one."""
+        if not self.path.exists():
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            return 0, GENESIS
+        last = None
+        with self.path.open("r", encoding="utf-8") as fh:
+            for line in fh:
+                line = line.strip()
+                if line:
+                    last = line
+        if last is None:
+            return 0, GENESIS
+        entry = json.loads(last)
+        return entry["seq"] + 1, entry["hash"]
+
+    def append(self, fields: dict) -> dict:
+        """Append one decision. ``fields`` must already be free of secret values."""
+        core = {"seq": self._seq, "prev": self._prev, **fields}
+        digest = _hash(self._prev, core)
+        entry = {**core, "hash": digest}
+        with self.path.open("a", encoding="utf-8") as fh:
+            fh.write(_canonical(entry) + "\n")
+        self._seq += 1
+        self._prev = digest
+        return entry
+
+
+def verify(path: str | Path) -> tuple[bool, int, str]:
+    """Re-walk the chain. Returns (ok, entries_checked, message)."""
+    p = Path(path)
+    if not p.exists():
+        return False, 0, f"no such audit log: {p}"
+    prev = GENESIS
+    count = 0
+    with p.open("r", encoding="utf-8") as fh:
+        for lineno, raw in enumerate(fh, start=1):
+            raw = raw.strip()
+            if not raw:
+                continue
+            try:
+                entry = json.loads(raw)
+            except json.JSONDecodeError as exc:
+                return False, count, f"line {lineno}: invalid JSON ({exc})"
+            stored = entry.get("hash")
+            core = {k: v for k, v in entry.items() if k != "hash"}
+            if core.get("seq") != count:
+                return False, count, f"line {lineno}: seq {core.get('seq')} != expected {count}"
+            if core.get("prev") != prev:
+                return False, count, f"line {lineno}: broken chain (prev mismatch)"
+            if _hash(prev, core) != stored:
+                return False, count, f"line {lineno}: hash mismatch (entry was altered)"
+            prev = stored
+            count += 1
+    return True, count, f"OK: {count} entries, chain intact"

sproxy/auth.py

@@ -0,0 +1,34 @@
+"""Small, dependency-free helpers for HTTP authentication headers."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+
+
+def decode_basic_authorization(value: str) -> str | None:
+    """Return Basic-auth credentials as text, or ``None`` for another scheme."""
+    parts = value.split(None, 1)
+    if len(parts) != 2 or parts[0].lower() != "basic":
+        return None
+    try:
+        return base64.b64decode(parts[1], validate=True).decode("utf-8")
+    except (binascii.Error, UnicodeDecodeError):
+        return None
+
+
+def inject_basic_placeholder(value: str, placeholder: str, secret: str) -> str:
+    """Replace a placeholder inside an HTTP Basic-auth header, if present.
+
+    Clients such as curl Base64-encode ``--user`` before the proxy receives the
+    request, so ordinary text replacement cannot see a placeholder there.
+    Invalid/non-Basic values are returned unchanged.
+    """
+    credentials = decode_basic_authorization(value)
+    if credentials is None or placeholder not in credentials:
+        return value
+    scheme = value.split(None, 1)[0]
+    encoded = base64.b64encode(
+        credentials.replace(placeholder, secret).encode("utf-8")
+    ).decode("ascii")
+    return f"{scheme} {encoded}"

sproxy/ca.py

@@ -0,0 +1,69 @@
+"""mitmproxy CA certificate discovery and the environment a proxied child needs.
+
+mitmproxy generates its CA on first run under ``confdir`` (default ``~/.mitmproxy``)
+as ``mitmproxy-ca-cert.pem``. Coding agents and their tools verify TLS against
+their own trust stores, so we point the well-known CA env vars at that file
+rather than touching the system trust store (which would need sudo).
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+CERT_NAME = "mitmproxy-ca-cert.pem"
+
+
+def default_confdir() -> Path:
+    return Path.home() / ".mitmproxy"
+
+
+def cert_path(confdir: str | Path | None = None) -> Path:
+    base = Path(confdir) if confdir else default_confdir()
+    return base.expanduser() / CERT_NAME
+
+
+def wait_for_cert(path: str | Path, timeout: float = 15.0) -> bool:
+    """Poll until the CA cert exists and is non-empty."""
+    p = Path(path)
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if p.exists() and p.stat().st_size > 0:
+            return True
+        time.sleep(0.1)
+    return p.exists() and p.stat().st_size > 0
+
+
+def proxy_env(port: int, cert: str | Path, base: dict | None = None) -> dict:
+    """Return the environment for a child process routed through the proxy.
+
+    Covers Node/Claude Code (``NODE_EXTRA_CA_CERTS``), Python requests/httpx,
+    curl and git, and both upper/lower-case proxy variables.  Node 24's native
+    HTTP clients only honour proxy environment variables when
+    ``NODE_USE_ENV_PROXY`` is enabled.
+    """
+    env = dict(os.environ if base is None else base)
+    url = f"http://127.0.0.1:{port}"
+    cert = str(cert)
+    env.update(
+        {
+            "HTTP_PROXY": url,
+            "HTTPS_PROXY": url,
+            "http_proxy": url,
+            "https_proxy": url,
+            "ALL_PROXY": url,
+            # Enables HTTP(S)_PROXY support in Node's built-in fetch/http
+            # clients (used by tools such as the bundled Sentry CLI).
+            "NODE_USE_ENV_PROXY": "1",
+            "NODE_EXTRA_CA_CERTS": cert,
+            "SSL_CERT_FILE": cert,
+            "REQUESTS_CA_BUNDLE": cert,
+            "CURL_CA_BUNDLE": cert,
+            "GIT_SSL_CAINFO": cert,
+            # Don't route localhost through the proxy.
+            "NO_PROXY": "localhost,127.0.0.1,::1",
+            "no_proxy": "localhost,127.0.0.1,::1",
+        }
+    )
+    return env