snulbug 0.2.0__tar.gz → 0.2.1__tar.gz

{snulbug-0.2.0 → snulbug-0.2.1}/CHANGELOG.md

@@ -6,6 +6,21 @@ The format is based on Keep a Changelog, and this project follows semantic versi
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-10-15
+
+Expose web applications and APIs alongside MCP through one gateway and ngrok tunnel.
+
+- Added `[[mcp.proxy.http_routes]]` mounts with longest-prefix routing, segment-boundary matching, configurable prefix stripping, and reserved MCP/gateway paths.
+- Added repeatable `--http-route PREFIX=URL` flags to share creation and quickstart, with matching ngrok Traffic Policy rules that apply MCP edge checks only to the MCP endpoint.
+- Added streaming HTTP uploads, responses, and SSE with disconnect cleanup, ordinary HTTP headers/cookies/content encodings, and plain HTTP upstream errors; included local proxy/facade regression coverage and setup documentation.
+- Raised the PyJWT minimum to 2.15 and updated the lockfile to exclude the versions flagged by the current JWT security advisories.
+
+HTTP mounts bypass MCP authentication, leases, Lua, redaction, and MCP evidence
+logging; each backend owns its authentication. Applications must configure their
+public base path. WebSockets and rewriting HTML, redirects, or cookie paths are
+outside this slice. See [shared HTTP routes](docs/mcp-proxy.md#shared-http-routes)
+and the [ngrok walkthrough](docs/ngrok-end-to-end.md).
+
 ## [0.2.0] - 2026-09-06
 
 This release expands MCP protocol support while keeping **2025-11-25 as the default**.

{snulbug-0.2.0 → snulbug-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: snulbug
-Version: 0.2.0
+Version: 0.2.1
 Summary: A local-dev MCP policy proxy with Lua policies, replay logs, and learned least-privilege bundles
 Project-URL: Homepage, https://github.com/nahuaque/snulbug
 Project-URL: Repository, https://github.com/nahuaque/snulbug
@@ -26,7 +26,7 @@ Requires-Python: >=3.10
 Requires-Dist: httpx<1,>=0.28
 Requires-Dist: jsonschema<5,>=4.23
 Requires-Dist: lupa>=2.5
-Requires-Dist: pyjwt[crypto]>=2.8
+Requires-Dist: pyjwt[crypto]>=2.15
 Requires-Dist: referencing<1,>=0.35
 Requires-Dist: rich>=15.0.0
 Requires-Dist: tomli>=2.0; python_version < '3.11'

{snulbug-0.2.0 → snulbug-0.2.1}/docs/devcontainers.md

@@ -10,8 +10,8 @@ servers with a shared control plane.
 ```json
 {
   "features": {
-    "ghcr.io/nahuaque/snulbug/features/snulbug:0.2.0": {
-      "version": "0.2.0",
+    "ghcr.io/nahuaque/snulbug/features/snulbug:0.2.1": {
+      "version": "0.2.1",
       "mode": "member-agent",
       "policy_profile": "tunnel-safe",
       "registry": "redis://redis:6379/0",

{snulbug-0.2.0 → snulbug-0.2.1}/docs/mcp-proxy.md

@@ -109,6 +109,68 @@ curl -sS "${NGROK_URL}/mcp" \
   -d '{"jsonrpc":"2.0","id":"tools-list","method":"tools/list","params":{}}'
 ```
 
+## Shared HTTP Routes
+
+One gateway listener can expose MCP at `/mcp` and ordinary HTTP backends at
+other prefixes. Add mounts to the share's `snulbug.toml`:
+
+```toml
+[[mcp.proxy.http_routes]]
+prefix = "/app"
+upstream = "http://127.0.0.1:3000"
+strip_prefix = true
+
+[[mcp.proxy.http_routes]]
+prefix = "/api"
+upstream = "http://127.0.0.1:4000"
+strip_prefix = false
+```
+
+With prefix stripping (the default), `/app/notes?q=1` forwards to
+`http://127.0.0.1:3000/notes?q=1`. With `strip_prefix = false`, `/api/items`
+forwards to `http://127.0.0.1:4000/api/items`. A path in the upstream URL is
+prepended to the forwarded path. Prefix matches use segment boundaries:
+`/app` matches `/app` and `/app/...`, but not `/application`. The longest
+matching prefix wins. The MCP prefix, `/.well-known`, and `/snulbug` are reserved.
+
+These requests bypass the MCP middleware, including its authentication, task
+leases, Lua policies, body/response limits, redaction, and replay/audit logs.
+Each HTTP backend owns authentication and request validation. Application
+`Authorization` and cookies pass through; snulbug lease and internal headers
+are removed. Responses preserve status, content encoding, duplicate cookies,
+and end-to-end headers. Uploads and responses stream with backpressure and
+disconnect cleanup; the proxy timeout applies to upstream inactivity.
+
+Configure web applications to generate assets, redirects, and cookies for their
+public prefix (for example `/app/`), using their base URL/root-path setting or
+the forwarded host, protocol, and prefix headers. Snulbug does not rewrite HTML,
+redirect locations, or cookie paths. Use `strip_prefix = false` for an app that
+already serves its prefix. WebSocket upgrades are not supported by these HTTP mounts.
+
+Restart `share run` after editing mounts. The router works with proxy and facade
+MCP modes and any tunnel that forwards the gateway origin. For generated ngrok
+setup, register routes at share creation so the Cloud Endpoint policy permits
+them:
+
+```bash
+snulbug mcp share create \
+  --directory .snulbug/shares/shared-demo \
+  --provider ngrok \
+  --url https://YOUR-NGROK-CLOUD-ENDPOINT/mcp \
+  --upstream http://127.0.0.1:9000 \
+  --http-route /app=http://127.0.0.1:3000 \
+  --http-route /api=http://127.0.0.1:4000
+snulbug mcp share run .snulbug/shares/shared-demo
+```
+
+`--http-route` is repeatable and also available on `share quickstart`. CLI-created
+routes strip their prefix; change that field in TOML when needed. The generated
+ngrok Traffic Policy permits only the MCP endpoint and registered HTTP prefixes,
+and applies its bearer/method/JSON guards only to MCP. Attach the policy to the
+public Cloud Endpoint as described in the [ngrok walkthrough](ngrok-end-to-end.md).
+If prefixes change later, update and reattach the Cloud Endpoint policy as well
+as restarting the gateway; editing TOML alone does not update ngrok's cloud policy.
+
 ## Streamable HTTP edge hardening
 
 `snulbug` enforces MCP Streamable HTTP safety checks at the gateway boundary

{snulbug-0.2.0 → snulbug-0.2.1}/docs/mcp-share.md

@@ -563,6 +563,12 @@ Point clients at `mcp-client.facade.json` for this facade recipe.
 
 ## Public tunnel providers
 
+Shares can also mount HTTP applications on the same tunnel. Add repeatable
+`--http-route /app=http://127.0.0.1:3000` flags to `share create`; MCP stays at
+`/mcp`, while the app route bypasses MCP auth/policy and uses the backend's own
+authentication. Generated ngrok policies permit these prefixes and scope MCP
+checks to `/mcp`. See [shared HTTP routes](mcp-proxy.md#shared-http-routes).
+
 The share command also works with existing tunnel providers:
 
 ```bash

{snulbug-0.2.0 → snulbug-0.2.1}/docs/ngrok-end-to-end.md

@@ -72,6 +72,32 @@ The share writes the important files here:
 `mcp-client.json` contains the bearer token and lease token for the generated
 session. Treat it as secret-bearing material.
 
+### Optional: Share a Webapp on the Same Tunnel
+
+To expose an app on port 3000, add this flag to the `share create` command in
+step 2 before creating the share:
+
+```bash
+--http-route /app=http://127.0.0.1:3000
+```
+
+The generated gateway config and ngrok Traffic Policy now allow `/app` and
+`/app/...` alongside `/mcp`. After starting the app, gateway, and ngrok and
+attaching the generated policy, test both hops without MCP credentials:
+
+```bash
+curl -i http://127.0.0.1:8080/app/
+curl -i "${NGROK_PUBLIC_ORIGIN}/app/"
+```
+
+The route strips `/app` before forwarding, so the app receives `/`. Configure
+its public base path as `/app/` for asset links and redirects. App traffic
+bypasses all MCP authentication/policy/recording; the app owns its authentication.
+See [shared HTTP routes](mcp-proxy.md#shared-http-routes) for multiple backends
+and preserving prefixes. Existing shares need both a TOML route and an updated
+Cloud Endpoint Traffic Policy; changing TOML alone leaves ngrok's old deny rule
+in effect.
+
 ## 3. Export the generated client headers
 
 The generated share requires both bearer auth and an `x-snulbug-lease` header

{snulbug-0.2.0 → snulbug-0.2.1}/docs/release.md

@@ -24,7 +24,7 @@ The release QA suite runs:
 - isolated built-wheel CLI/module smoke tests outside the source checkout
 - installed-wheel protocol discovery and offline JSON Schema 2020-12 checks
 
-These checks do not certify client/provider E2E interoperability. For 0.2.0,
+These checks do not certify client/provider E2E interoperability. For 0.2.x,
 2025-11-25 remains the default and 2026-07-28 remains an opt-in preview.
 
 Before publishing, include all new modules, docs, tests, and fixtures in the
@@ -48,7 +48,7 @@ python -m zipfile -l dist/snulbug-*.whl
 8. Install from TestPyPI in a clean environment and smoke test:
 
 ```bash
-uvx --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ snulbug==0.2.0 --help
+uvx --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ snulbug==0.2.1 --help
 ```
 
 9. Run the manual `Publish` workflow with `repository = pypi` when the TestPyPI
@@ -56,4 +56,4 @@ uvx --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org
 10. Create the GitHub release and tag after the PyPI package is available.
 
 The `Publish` workflow uses `workflow_dispatch`, not a tag trigger. Creating or
-pushing `v0.2.0` does not publish a package or automatically create a GitHub release.
+pushing `v0.2.1` does not publish a package or automatically create a GitHub release.

{snulbug-0.2.0 → snulbug-0.2.1}/examples/codespace_local_gateway/.devcontainer/devcontainer.json

@@ -2,7 +2,7 @@
   "name": "snulbug Codespace MCP member",
   "features": {
     "ghcr.io/devcontainers/features/python:1": {},
-    "ghcr.io/nahuaque/snulbug/features/snulbug:0.2.0": {
+    "ghcr.io/nahuaque/snulbug/features/snulbug:0.2.1": {
       "install_source": "github",
       "github_ref": "main",
       "mode": "member-agent",

{snulbug-0.2.0 → snulbug-0.2.1}/features/snulbug/README.md

@@ -6,7 +6,7 @@ workspace helpers for Codespaces/devcontainers.
 ```json
 {
   "features": {
-    "ghcr.io/nahuaque/snulbug/features/snulbug:0.2.0": {
+    "ghcr.io/nahuaque/snulbug/features/snulbug:0.2.1": {
       "install_source": "github",
       "github_ref": "main",
       "mode": "member-agent",

{snulbug-0.2.0 → snulbug-0.2.1}/features/snulbug/devcontainer-feature.json

@@ -1,6 +1,6 @@
 {
   "id": "snulbug",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "name": "snulbug",
   "description": "Install snulbug and optional helpers for MCP policy gateways and remote fabric members in devcontainers.",
   "documentationURL": "https://github.com/nahuaque/snulbug/blob/main/docs/devcontainers.md",

{snulbug-0.2.0 → snulbug-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "snulbug"
-version = "0.2.0"
+version = "0.2.1"
 description = "A local-dev MCP policy proxy with Lua policies, replay logs, and learned least-privilege bundles"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -38,7 +38,7 @@ dependencies = [
     "httpx>=0.28,<1",
     "jsonschema>=4.23,<5",
     "lupa>=2.5",
-    "pyjwt[crypto]>=2.8",
+    "pyjwt[crypto]>=2.15",
     "referencing>=0.35,<1",
     "rich>=15.0.0",
     "tomli>=2.0; python_version < '3.11'",

{snulbug-0.2.0 → snulbug-0.2.1}/snulbug/__init__.py

@@ -1,6 +1,6 @@
 """Local-dev MCP policy proxy and programmable Lua ASGI policy layer."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 from .auth_providers import (
     AuthProvider,

{snulbug-0.2.0 → snulbug-0.2.1}/snulbug/cli/share.py

@@ -20,6 +20,7 @@ from ..cli_helpers import (
     write_result_output,
     write_sarif_output,
 )
+from ..http_routes import parse_http_route
 from .common import read_required_env
 
 PROVIDERS = ("generic", "ngrok", "cloudflare", "tailscale", "pinggy", "ssh", "holepunch")
@@ -445,6 +446,7 @@ def handle_mcp_share_command(args: argparse.Namespace, parser: argparse.Argument
                 config_output=args.config_output,
                 traces_dir=args.traces_dir,
                 upstream=args.upstream,
+                http_routes=args.http_route,
                 token=args.token,
                 token_env=args.token_env,
                 allowed_tools=args.allow_tool or None,
@@ -506,6 +508,7 @@ def handle_mcp_share_command(args: argparse.Namespace, parser: argparse.Argument
                 provider=args.provider,
                 preset=args.preset,
                 upstream=args.upstream,
+                http_routes=args.http_route,
                 hostname=args.hostname,
                 public_url=args.url,
                 ngrok_internal_url=args.ngrok_internal_url,
@@ -940,6 +943,7 @@ def _add_quickstart_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--config-output", type=Path, default=Path("snulbug.toml"), help="config file path")
     parser.add_argument("--traces-dir", type=Path, default=Path("traces"), help="trace directory path")
     parser.add_argument("--upstream", default="http://127.0.0.1:9000", help="upstream MCP HTTP server URL")
+    _add_http_route_arg(parser)
     add_token_arg(parser, help="bearer token to render into generated policy")
     add_token_env_arg(parser, help="context key used by generated policy for env-derived token lookup")
     parser.add_argument("--allow-tool", action="append", default=[], help="allowed MCP tool name")
@@ -1169,6 +1173,17 @@ def _add_cloudflare_access_setup_args(parser: argparse.ArgumentParser) -> None:
     )
 
 
+def _add_http_route_arg(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--http-route",
+        action="append",
+        type=parse_http_route,
+        default=[],
+        metavar="PREFIX=URL",
+        help="HTTP backend outside MCP auth/policy, e.g. /app=http://127.0.0.1:3000; strips prefix; repeatable",
+    )
+
+
 def _add_share_create_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--directory", type=Path, help="share session directory")
     parser.add_argument(
@@ -1179,6 +1194,7 @@ def _add_share_create_args(parser: argparse.ArgumentParser) -> None:
     )
     parser.add_argument("--preset", default="tunnel-safe", help="MCP policy preset")
     parser.add_argument("--upstream", default="http://127.0.0.1:9000", help="upstream MCP HTTP server")
+    _add_http_route_arg(parser)
     parser.add_argument(
         "--hostname",
         help="provider hostname to use when --url is omitted; for --provider ssh this is the SSH target user@host",

{snulbug-0.2.0 → snulbug-0.2.1}/snulbug/config.py

@@ -8,6 +8,7 @@ from .credentials import attach_upstream_credentials, normalize_fabric_credentia
 from .discovery import apply_fabric_discovery
 from .events import normalize_event_sink_configs
 from .gateway_templates import render_toml_array_table
+from .http_routes import normalize_http_routes
 from .mcp_protocol import DEFAULT_MCP_PROTOCOL_VERSION
 from .policy_backoff import (
     DEFAULT_POLICY_BACKOFF_EXCLUDE_REASON_CODES,
@@ -81,6 +82,7 @@ DEFAULT_MCP_PROXY_CONFIG = {
     "upstream": "http://127.0.0.1:9000",
     "upstream_credential": None,
     "upstreams": [],
+    "http_routes": [],
     "policy": "policy.snulbug/policy.lua",
     "host": "127.0.0.1",
     "port": 8080,
@@ -671,6 +673,9 @@ def normalize_mcp_proxy_config(config: Mapping[str, Any], *, base_dir: str | Pat
         raise ValueError("mcp.proxy.resource_subscription_policy_action must be 'allow', 'warn', or 'block'")
     if not normalized["streamable_http_endpoint_path"].startswith("/"):
         normalized["streamable_http_endpoint_path"] = f"/{normalized['streamable_http_endpoint_path']}"
+    normalized["http_routes"] = normalize_http_routes(
+        normalized.get("http_routes", []), mcp_path=normalized["streamable_http_endpoint_path"]
+    )
     normalized["streamable_http_allowed_origins"] = _normalize_string_list(
         normalized.get("streamable_http_allowed_origins", []),
         field="streamable_http_allowed_origins",

{snulbug-0.2.0 → snulbug-0.2.1}/snulbug/gateway_templates.py

@@ -13,6 +13,7 @@ class GatewayTemplate:
 
     proxy: Mapping[str, Any] = field(default_factory=dict)
     upstreams: Sequence[Mapping[str, Any]] = ()
+    http_routes: Sequence[Mapping[str, Any]] = ()
     auth: Mapping[str, Any] | None = None
     event_sinks: Sequence[Mapping[str, Any]] = ()
     fabric: Mapping[str, Any] | None = None
@@ -39,6 +40,8 @@ def render_gateway_toml(template: GatewayTemplate, *, header: str | None = None)
         _append_block(lines, render_toml_table("mcp.proxy", template.proxy))
     for upstream in template.upstreams:
         _append_block(lines, render_toml_array_table("mcp.proxy.upstreams", upstream))
+    for route in template.http_routes:
+        _append_block(lines, render_toml_array_table("mcp.proxy.http_routes", route))
     if template.auth is not None:
         _append_block(lines, render_toml_table("mcp.auth", template.auth))
     for sink in template.event_sinks:

snulbug-0.2.1/snulbug/http_routes.py

@@ -0,0 +1,239 @@
+"""Explicit HTTP mounts outside the MCP middleware stack."""
+
+from __future__ import annotations
+
+import asyncio
+import math
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Any
+from urllib.parse import quote, urlsplit
+
+import httpx
+
+if TYPE_CHECKING:
+    from .middleware import ASGIApp, Receive, Scope, Send
+
+HOP_HEADERS = {
+    b"connection",
+    b"keep-alive",
+    b"proxy-authenticate",
+    b"proxy-authorization",
+    b"proxy-connection",
+    b"te",
+    b"trailer",
+    b"transfer-encoding",
+    b"upgrade",
+}
+
+
+class _ClientDisconnected(Exception):
+    pass
+
+
+def path_matches(path: str, prefix: str) -> bool:
+    return path == prefix or path.startswith(prefix + "/")
+
+
+def normalize_http_routes(routes: Any, *, mcp_path: str = "/mcp") -> list[dict[str, Any]]:
+    if not isinstance(routes, (list, tuple)):
+        raise ValueError("mcp.proxy.http_routes must be an array of tables")
+    reserved = (mcp_path.rstrip("/") or "/", "/.well-known", "/snulbug")
+    result = []
+    prefixes = set()
+    for route in routes:
+        if not isinstance(route, Mapping) or set(route) - {"prefix", "upstream", "strip_prefix"}:
+            raise ValueError("HTTP routes support only prefix, upstream, and strip_prefix")
+        prefix = route.get("prefix")
+        if (
+            not isinstance(prefix, str)
+            or not prefix.startswith("/")
+            or not prefix.isascii()
+            or any(char.isspace() or ord(char) < 32 or ord(char) == 127 for char in prefix)
+            or any(char in prefix for char in ("?", "#", "%", "\\"))
+            or quote(prefix, safe="/:@!$&'()*+,;=-._~") != prefix
+            or "//" in prefix
+            or any(segment in {".", ".."} for segment in prefix.split("/"))
+        ):
+            raise ValueError("HTTP route prefix must be an absolute, unescaped URL path")
+        prefix = prefix.rstrip("/")
+        if not prefix or any(
+            item == "/" or path_matches(prefix, item) or path_matches(item, prefix) for item in reserved
+        ):
+            raise ValueError("HTTP route prefix overlaps MCP or reserved gateway paths")
+        if prefix in prefixes:
+            raise ValueError(f"duplicate HTTP route prefix: {prefix}")
+        upstream = route.get("upstream")
+        if not isinstance(upstream, str) or any(char.isspace() or ord(char) < 32 for char in upstream):
+            raise ValueError("HTTP route upstream must be an absolute http:// or https:// URL")
+        try:
+            parsed = urlsplit(upstream)
+            port = parsed.port
+            httpx.URL(upstream)
+        except (ValueError, httpx.InvalidURL) as exc:
+            raise ValueError("invalid HTTP route upstream URL") from exc
+        if (
+            parsed.scheme not in {"http", "https"}
+            or not parsed.hostname
+            or parsed.username is not None
+            or parsed.password is not None
+            or parsed.query
+            or parsed.fragment
+            or "\\" in upstream
+            or port == 0
+        ):
+            raise ValueError("HTTP route upstream requires HTTP(S), without credentials, query, or fragment")
+        strip = route.get("strip_prefix", True)
+        if not isinstance(strip, bool):
+            raise ValueError("HTTP route strip_prefix must be a boolean")
+        prefixes.add(prefix)
+        result.append({"prefix": prefix, "upstream": upstream.rstrip("/"), "strip_prefix": strip})
+    return result
+
+
+def parse_http_route(value: str) -> dict[str, Any]:
+    prefix, separator, upstream = value.partition("=")
+    if not separator:
+        raise ValueError("--http-route requires PREFIX=URL, for example /app=http://127.0.0.1:3000")
+    return normalize_http_routes([{"prefix": prefix, "upstream": upstream}])[0]
+
+
+def _end_to_end_headers(headers: Sequence[tuple[bytes, bytes]]) -> list[tuple[bytes, bytes]]:
+    connection_tokens = {
+        token.strip().lower() for name, value in headers if name.lower() == b"connection" for token in value.split(b",")
+    }
+    return [(name.lower(), value) for name, value in headers if name.lower() not in HOP_HEADERS | connection_tokens]
+
+
+class HttpRoutesMiddleware:
+    def __init__(
+        self,
+        app: ASGIApp,
+        routes: Sequence[Mapping[str, Any]],
+        *,
+        mcp_path: str = "/mcp",
+        timeout: float = 30.0,
+        lease_header: str = "x-snulbug-lease",
+    ) -> None:
+        self.app = app
+        self.routes = sorted(normalize_http_routes(routes, mcp_path=mcp_path), key=lambda r: -len(r["prefix"]))
+        if not math.isfinite(timeout) or timeout <= 0:
+            raise ValueError("HTTP route timeout must be positive and finite")
+        self.timeout = timeout
+        self.lease_header = lease_header.lower().encode("ascii")
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        route = next((route for route in self.routes if path_matches(scope.get("path", ""), route["prefix"])), None)
+        if scope["type"] not in {"http", "websocket"} or route is None:
+            await self.app(scope, receive, send)
+            return
+        if scope["type"] == "websocket":
+            await send({"type": "websocket.close", "code": 1008, "reason": "HTTP routes do not support WebSockets"})
+            return
+        raw_path = scope.get("raw_path", scope["path"].encode("utf-8"))
+        prefix = route["prefix"].encode("ascii")
+        if any(part in {".", ".."} for part in scope["path"].split("/")) or not (
+            raw_path == prefix or raw_path.startswith(prefix + b"/")
+        ):
+            await self._error(send, 400, b"Invalid route path")
+            return
+        body_done = asyncio.Event()
+        proxy = asyncio.create_task(self._forward(route, scope, raw_path, body_done, receive, send))
+        disconnected = asyncio.create_task(self._wait_disconnect(receive, body_done))
+        try:
+            done, _ = await asyncio.wait({proxy, disconnected}, return_when=asyncio.FIRST_COMPLETED)
+            if proxy in done:
+                await proxy
+        finally:
+            for task in (proxy, disconnected):
+                if not task.done():
+                    task.cancel()
+            await asyncio.gather(proxy, disconnected, return_exceptions=True)
+
+    async def _wait_disconnect(self, receive: Receive, body_done: asyncio.Event) -> None:
+        await body_done.wait()
+        while (await receive())["type"] != "http.disconnect":
+            pass
+
+    async def _forward(self, route, scope, raw_path, body_done, receive, send) -> None:
+        first = await receive()
+        if first["type"] == "http.disconnect":
+            return
+
+        async def body():
+            message = first
+            while True:
+                if message["type"] == "http.disconnect":
+                    raise _ClientDisconnected
+                if not message.get("more_body", False):
+                    body_done.set()
+                yield message.get("body", b"")
+                if not message.get("more_body", False):
+                    return
+                message = await receive()
+
+        content = body()
+        if not first.get("body") and not first.get("more_body", False):
+            content = b""
+            body_done.set()
+        base = httpx.URL(route["upstream"])
+        suffix = raw_path[len(route["prefix"]) :] if route["strip_prefix"] else raw_path
+        target_path = base.raw_path.rstrip(b"/") + (suffix or b"/")
+        query = scope.get("query_string", b"")
+        target = base.copy_with(raw_path=target_path + (b"?" + query if query else b""))
+        headers = self._request_headers(scope, route)
+        started = False
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout, trust_env=False, follow_redirects=False) as client:
+                async with client.stream(scope["method"], target, headers=headers, content=content) as response:
+                    await send(
+                        {
+                            "type": "http.response.start",
+                            "status": response.status_code,
+                            "headers": _end_to_end_headers(response.headers.raw),
+                        }
+                    )
+                    started = True
+                    async for chunk in response.aiter_raw():
+                        await send({"type": "http.response.body", "body": chunk, "more_body": True})
+                    await send({"type": "http.response.body", "body": b"", "more_body": False})
+        except _ClientDisconnected:
+            return
+        except (httpx.HTTPError, OSError) as exc:
+            if started:
+                raise
+            if isinstance(exc, httpx.TimeoutException):
+                await self._error(send, 504, b"HTTP route upstream timed out")
+            else:
+                await self._error(send, 502, b"HTTP route upstream unavailable")
+
+    def _request_headers(self, scope: Scope, route: Mapping[str, Any]) -> list[tuple[bytes, bytes]]:
+        headers = []
+        original_host = b""
+        for name, value in _end_to_end_headers(scope.get("headers", [])):
+            if name == b"host":
+                original_host = value
+            elif not (
+                name.startswith((b"x-snulbug-", b"x-forwarded-")) or name in {self.lease_header, b"forwarded", b"dpop"}
+            ):
+                headers.append((name, value))
+        if original_host:
+            headers.append((b"x-forwarded-host", original_host))
+        headers.append((b"x-forwarded-proto", scope.get("scheme", "http").encode("ascii")))
+        headers.append((b"x-forwarded-prefix", route["prefix"].encode("ascii")))
+        if scope.get("client"):
+            headers.append((b"x-forwarded-for", scope["client"][0].encode("ascii")))
+        return headers
+
+    @staticmethod
+    async def _error(send: Send, status: int, body: bytes) -> None:
+        await send(
+            {
+                "type": "http.response.start",
+                "status": status,
+                "headers": [
+                    (b"content-type", b"text/plain; charset=utf-8"),
+                    (b"content-length", str(len(body)).encode("ascii")),
+                ],
+            }
+        )
+        await send({"type": "http.response.body", "body": body})

{snulbug-0.2.0 → snulbug-0.2.1}/snulbug/proxy.py

@@ -31,6 +31,7 @@ from .credentials import apply_credential_header, credential_metadata, normalize
 from .events import build_event_dispatcher, decision_console_event
 from .fabric import annotate_topology_audit, build_fabric_audit_metadata
 from .fabric_control import summarize_fabric_control_state
+from .http_routes import HttpRoutesMiddleware
 from .leases import (
     LeasePolicyConfig,
     enforce_mcp_lease_policy,
@@ -2944,6 +2945,7 @@ def create_proxy_application(
     *,
     upstream_credential: Mapping[str, Any] | None = None,
     upstreams: Sequence[FacadeUpstream | Mapping[str, Any]] | None = None,
+    http_routes: Sequence[Mapping[str, Any]] = (),
     state_store: PolicyStateStore | None = None,
     state_limits: StateLimits | None = None,
     trace: bool = True,
@@ -3187,6 +3189,10 @@ def create_proxy_application(
             topology_audit=topology_audit,
             control_state_provider=fabric_control_state_provider,
         )
+    if http_routes:
+        app = HttpRoutesMiddleware(
+            app, http_routes, mcp_path=streamable_http_config.endpoint_path, timeout=timeout, lease_header=lease_header
+        )
     return app
 
 
@@ -3196,6 +3202,7 @@ def run_proxy(
     policy: str | Path,
     upstream_credential: Mapping[str, Any] | None = None,
     upstreams: Sequence[FacadeUpstream | Mapping[str, Any]] | None = None,
+    http_routes: Sequence[Mapping[str, Any]] = (),
     host: str = "127.0.0.1",
     port: int = 8080,
     state: str = "memory",
@@ -3276,6 +3283,7 @@ def run_proxy(
         policy,
         upstream_credential=upstream_credential,
         upstreams=upstreams,
+        http_routes=http_routes,
         state_store=_state_store(state),
         trace=trace,
         max_body_bytes=max_body_bytes,
@@ -3365,6 +3373,7 @@ def proxy_config_run_kwargs(
         "upstream": proxy_config["upstream"],
         "upstream_credential": proxy_config.get("upstream_credential"),
         "upstreams": proxy_config["upstreams"],
+        "http_routes": proxy_config.get("http_routes", []),
         "policy": proxy_config["policy"],
         "host": proxy_config["host"],
         "port": proxy_config["port"],