mobiusguard 0.1.0__py3-none-any.whl

mobiusguard/__init__.py

@@ -0,0 +1,6 @@
+"""Mobius Guard: an OpenAI-compatible LLM firewall proxy.
+
+Streaming redaction and an honest, held-out evaluation.
+"""
+
+__version__ = "0.1.0"

mobiusguard/apis.py

@@ -0,0 +1,171 @@
+"""The three APIs the proxy speaks: where their text is, and how they report an error.
+
+The proxy never rebuilds a request. It reads the text fields the model will see (for the
+request path) and the text and argument deltas the model writes (for the response path),
+and passes everything else through as it came.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal, cast
+
+from .config import Config, Upstream
+
+Role = str
+
+
+@dataclass(frozen=True, slots=True)
+class Text:
+    """One piece of text the model will read, and where it is in the request."""
+
+    role: Role  # system | user | assistant | tool | developer
+    text: str
+    where: str  # e.g. "messages[2].content[0]"
+
+
+Json = dict[str, Any]
+
+
+def _as_dict(v: object) -> Json:
+    return cast("Json", v) if isinstance(v, dict) else {}
+
+
+def _as_list(v: object) -> list[Any]:
+    return cast("list[Any]", v) if isinstance(v, list) else []
+
+
+class Api:
+    name: Literal["chat", "responses", "anthropic"]
+    path: str  # route on the proxy
+    upstream_path: str  # appended to the upstream base URL
+
+    def upstream(self, cfg: Config) -> Upstream:
+        return cfg.openai
+
+    def texts(self, body: Json) -> list[Text]:
+        raise NotImplementedError
+
+    def is_stream(self, body: Json) -> bool:
+        return body.get("stream") is True
+
+    def error(self, status: int, message: str, code: str, details: Json | None = None) -> Json:
+        """An error body in this API's own format (OpenAI style by default)."""
+        err: Json = {"message": message, "type": _openai_type(status), "param": None, "code": code}
+        body: Json = {"error": err}
+        if details:
+            err["mobiusguard"] = details
+        return body
+
+    def set_key(self, headers: dict[str, str], key: str) -> None:
+        headers.pop("x-api-key", None)
+        headers["authorization"] = f"Bearer {key}"
+
+    def caller_key(self, headers: dict[str, str]) -> str:
+        auth = headers.get("authorization", "")
+        return auth[7:].strip() if auth.lower().startswith("bearer ") else ""
+
+
+def _openai_type(status: int) -> str:
+    names = {400: "invalid_request_error", 401: "authentication_error",
+             403: "permission_error", 413: "invalid_request_error"}  # fmt: skip
+    return names.get(status, "api_error")
+
+
+def _parts(content: object, where: str, role: Role, kinds: tuple[str, ...]) -> list[Text]:
+    """Text from a string or a list of typed parts ({"type": "text", "text": ...})."""
+    if isinstance(content, str):
+        return [Text(role, content, where)] if content else []
+    out: list[Text] = []
+    for j, part in enumerate(_as_list(content)):
+        p = _as_dict(part)
+        if p.get("type") in kinds and isinstance(p.get("text"), str) and p["text"]:
+            out.append(Text(role, p["text"], f"{where}[{j}]"))
+    return out
+
+
+class ChatCompletions(Api):
+    name = "chat"
+    path = "/v1/chat/completions"
+    upstream_path = "chat/completions"
+
+    def texts(self, body: Json) -> list[Text]:
+        out: list[Text] = []
+        for i, msg in enumerate(_as_list(body.get("messages"))):
+            m = _as_dict(msg)
+            role = str(m.get("role", "user"))
+            out += _parts(m.get("content"), f"messages[{i}].content", role, ("text",))
+        return out
+
+
+class Responses(Api):
+    name = "responses"
+    path = "/v1/responses"
+    upstream_path = "responses"
+
+    def texts(self, body: Json) -> list[Text]:
+        out: list[Text] = []
+        if isinstance(body.get("instructions"), str) and body["instructions"]:
+            out.append(Text("system", body["instructions"], "instructions"))
+        inp = body.get("input")
+        if isinstance(inp, str):
+            return [*out, Text("user", inp, "input")] if inp else out
+        kinds = ("input_text", "output_text", "text")
+        for i, item in enumerate(_as_list(inp)):
+            it = _as_dict(item)
+            where = f"input[{i}]"
+            if it.get("type") == "function_call_output":
+                output = it.get("output")
+                if isinstance(output, str) and output:
+                    out.append(Text("tool", output, f"{where}.output"))
+                else:
+                    out += _parts(output, f"{where}.output", "tool", kinds)
+            elif "content" in it:
+                out += _parts(
+                    it.get("content"), f"{where}.content", str(it.get("role", "user")), kinds
+                )
+        return out
+
+
+class AnthropicMessages(Api):
+    name = "anthropic"
+    path = "/v1/messages"
+    upstream_path = "messages"
+
+    def upstream(self, cfg: Config) -> Upstream:
+        return cfg.anthropic
+
+    def texts(self, body: Json) -> list[Text]:
+        out = _parts(body.get("system"), "system", "system", ("text",))
+        for i, msg in enumerate(_as_list(body.get("messages"))):
+            m = _as_dict(msg)
+            role = str(m.get("role", "user"))
+            content = m.get("content")
+            out += _parts(content, f"messages[{i}].content", role, ("text",))
+            for j, block in enumerate(_as_list(content)):
+                b = _as_dict(block)
+                if b.get("type") == "tool_result":
+                    out += _parts(b.get("content"), f"messages[{i}].content[{j}].content", "tool",
+                                  ("text",))  # fmt: skip
+        return out
+
+    def error(self, status: int, message: str, code: str, details: Json | None = None) -> Json:
+        err: Json = {"type": _anthropic_type(status), "message": message}
+        if details:
+            err["mobiusguard"] = {"code": code, **details}
+        return {"type": "error", "error": err}
+
+    def set_key(self, headers: dict[str, str], key: str) -> None:
+        headers.pop("authorization", None)
+        headers["x-api-key"] = key
+
+    def caller_key(self, headers: dict[str, str]) -> str:
+        return headers.get("x-api-key", "") or super().caller_key(headers)
+
+
+def _anthropic_type(status: int) -> str:
+    return {400: "invalid_request_error", 401: "authentication_error",
+            403: "permission_error", 413: "request_too_large"}.get(status, "api_error")  # fmt: skip
+
+
+APIS: tuple[Api, ...] = (ChatCompletions(), Responses(), AnthropicMessages())

mobiusguard/app.py

@@ -0,0 +1,186 @@
+"""The proxy: one handler for the three APIs, a pass-through for model lists.
+
+Order for each request: caller check, size and JSON check, the request check (rules,
+classifier, policy), then the upstream call; the reply is redacted on its way back. A block
+or an error is answered in the API's own error format.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
+from contextlib import asynccontextmanager
+
+import httpx
+from starlette.applications import Starlette
+from starlette.background import BackgroundTask
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response, StreamingResponse
+from starlette.routing import Route
+
+from . import sse
+from .apis import APIS, Api, Json
+from .config import Config
+
+# Headers passed on to the upstream; everything else (cookies, host, hop-by-hop) is dropped.
+FORWARD = {
+    "authorization", "x-api-key", "anthropic-version", "anthropic-beta", "openai-organization",
+    "openai-project", "openai-beta", "user-agent", "accept", "idempotency-key",
+}  # fmt: skip
+# Headers passed back from the upstream.
+RETURN_PREFIXES = ("x-request-id", "request-id", "openai-", "anthropic-", "x-ratelimit-",
+                   "retry-after")  # fmt: skip
+
+
+class Hooks:
+    """What runs inside a request. Part 3a passes everything through; the guard (3b) and
+    the redaction (3c) replace these."""
+
+    async def check(self, api: Api, body: Json, request: Request, state: Json) -> Json | None:
+        """None to forward the request, or ``{"status", "message", "code", "details"}``."""
+        return None
+
+    def rewrite_json(self, api: Api, body: Json, state: Json) -> Json:
+        return body
+
+    def rewrite_events(
+        self, api: Api, events: AsyncIterator[sse.Event], state: Json
+    ) -> AsyncIterator[sse.Event]:
+        return events
+
+    def finish(self, api: Api, state: Json) -> None:
+        """Called once the reply has been sent (audit)."""
+
+
+def _forward_headers(request: Request, api: Api, cfg: Config) -> dict[str, str]:
+    headers = {k.lower(): v for k, v in request.headers.items()}
+    out = {k: v for k, v in headers.items() if k in FORWARD or k.startswith("x-stainless-")}
+    key = api.upstream(cfg).api_key()
+    if key:
+        api.set_key(out, key)
+    out["accept-encoding"] = "identity"  # we read the stream as it arrives
+    out["content-type"] = "application/json"
+    return out
+
+
+def _return_headers(resp: httpx.Response) -> dict[str, str]:
+    return {k: v for k, v in resp.headers.items() if k.lower().startswith(RETURN_PREFIXES)}
+
+
+def create_app(
+    cfg: Config, *, hooks: Hooks | None = None, transport: httpx.AsyncBaseTransport | None = None
+) -> Starlette:
+    hooks = hooks or Hooks()
+    clients: dict[str, httpx.AsyncClient] = {}
+
+    @asynccontextmanager
+    async def lifespan(_: Starlette) -> AsyncGenerator[None]:
+        clients["http"] = httpx.AsyncClient(
+            timeout=httpx.Timeout(cfg.limits.timeout_seconds, connect=10), transport=transport
+        )
+        try:
+            yield
+        finally:
+            await clients["http"].aclose()
+
+    def fail(
+        api: Api, status: int, message: str, code: str, details: Json | None = None
+    ) -> Response:
+        return JSONResponse(api.error(status, message, code, details), status_code=status)
+
+    def handler(api: Api) -> Callable[[Request], Awaitable[Response]]:
+        async def handle(request: Request) -> Response:
+            state: Json = {"started": time.perf_counter(), "api": api.name}
+            if cfg.client_tokens:
+                headers = {k.lower(): v for k, v in request.headers.items()}
+                if api.caller_key(headers) not in cfg.client_tokens:
+                    return fail(api, 401, "Missing or unknown Mobius Guard client token.",
+                                "unauthorized")  # fmt: skip
+            raw = await request.body()
+            if len(raw) > cfg.limits.max_body_bytes:
+                return fail(api, 413, "Request body too large for Mobius Guard.", "too_large")
+            try:
+                body = json.loads(raw)
+            except json.JSONDecodeError:
+                return fail(api, 400, "Request body is not valid JSON.", "invalid_json")
+            if not isinstance(body, dict):
+                return fail(api, 400, "Request body must be a JSON object.", "invalid_json")
+            body_d: Json = body  # pyright: ignore[reportUnknownVariableType]
+            state["model"] = str(body_d.get("model", ""))
+            state["stream"] = api.is_stream(body_d)
+
+            blocked = await hooks.check(api, body_d, request, state)
+            if blocked is not None:
+                state["decision"] = "block"
+                hooks.finish(api, state)
+                return fail(api, int(blocked["status"]), str(blocked["message"]),
+                            str(blocked["code"]), blocked.get("details"))  # fmt: skip
+            state.setdefault("decision", "allow")
+
+            up = api.upstream(cfg)
+            url = f"{up.base_url.rstrip('/')}/{api.upstream_path}"
+            client = clients["http"]
+            req = client.build_request("POST", url, content=raw,
+                                       headers=_forward_headers(request, api, cfg))  # fmt: skip
+            try:
+                resp = await client.send(req, stream=True)
+            except httpx.HTTPError as e:
+                state["upstream_error"] = type(e).__name__
+                hooks.finish(api, state)
+                return fail(
+                    api, 502, f"Upstream unreachable: {type(e).__name__}.", "upstream_error"
+                )
+            state["upstream_status"] = resp.status_code
+            ctype = resp.headers.get("content-type", "")
+
+            if resp.status_code == 200 and ctype.startswith("text/event-stream"):
+                events = hooks.rewrite_events(api, sse.parse(resp.aiter_bytes()), state)
+
+                async def body_iter() -> AsyncIterator[bytes]:
+                    async for ev in events:
+                        yield ev.encode()
+
+                def done() -> None:
+                    hooks.finish(api, state)
+
+                async def close() -> None:
+                    await resp.aclose()
+                    done()
+
+                return StreamingResponse(body_iter(), media_type="text/event-stream",
+                                         headers=_return_headers(resp),
+                                         background=BackgroundTask(close))  # fmt: skip
+
+            content = await resp.aread()
+            await resp.aclose()
+            if resp.status_code == 200 and ctype.startswith("application/json"):
+                try:
+                    data = json.loads(content)
+                except json.JSONDecodeError:
+                    data = None
+                if isinstance(data, dict):
+                    out = hooks.rewrite_json(api, data, state)  # pyright: ignore[reportUnknownArgumentType]
+                    hooks.finish(api, state)
+                    return JSONResponse(out, status_code=200, headers=_return_headers(resp))
+            hooks.finish(api, state)
+            # Errors and anything we don't understand go back as they came.
+            return Response(content, status_code=resp.status_code, media_type=ctype or None,
+                            headers=_return_headers(resp))  # fmt: skip
+
+        return handle
+
+    async def models(request: Request) -> Response:
+        api = APIS[0]
+        url = f"{cfg.openai.base_url.rstrip('/')}/models"
+        resp = await clients["http"].get(url, headers=_forward_headers(request, api, cfg))
+        return Response(resp.content, status_code=resp.status_code,
+                        media_type=resp.headers.get("content-type"),
+                        headers=_return_headers(resp))  # fmt: skip
+
+    async def health(_: Request) -> Response:
+        return JSONResponse({"status": "ok"})
+
+    routes = [Route(api.path, handler(api), methods=["POST"]) for api in APIS]
+    routes += [Route("/v1/models", models, methods=["GET"]), Route("/healthz", health)]
+    return Starlette(routes=routes, lifespan=lifespan)

mobiusguard/audit.py

@@ -0,0 +1,100 @@
+"""The audit log and telemetry: what was decided for each request, never the text by default.
+
+One JSON line per request: when, which API and model, the decision and why (rule IDs,
+severity, which view matched), the classifier score, what was redacted (pattern IDs and
+counts), timings and a hash of the checked prompt. Prompt text is written only when
+``[audit] include_text = true``. API keys are never written.
+
+OpenTelemetry spans (GenAI semantic conventions) are emitted when ``opentelemetry-api`` is
+installed (``mobiusguard[otel]``) and an SDK is configured by the host.
+"""
+
+from __future__ import annotations
+
+import importlib
+import json
+import threading
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from .apis import Json
+from .guard import Decision
+from .outbound import Redactors
+
+SYSTEM = {"chat": "openai", "responses": "openai", "anthropic": "anthropic"}
+
+
+def record(state: Json) -> Json:
+    """The audit record for one request, from the state the handler collected."""
+    d = state.get("guard")
+    red = state.get("redactors")
+    out: Json = {
+        "time": datetime.now(UTC).isoformat(timespec="milliseconds"),
+        "api": state.get("api"),
+        "model": state.get("model", ""),
+        "stream": bool(state.get("stream")),
+        "decision": state.get("decision", "allow"),
+        "ms": round(
+            (time.perf_counter() - float(state.get("started", time.perf_counter()))) * 1000, 1
+        ),
+    }
+    if isinstance(d, Decision):
+        out["reason"] = d.reason
+        out["rules"] = [{"id": h.rule, "severity": h.severity, "view": h.view, "where": h.where}
+                        for h in d.hits]  # fmt: skip
+        out["score"] = None if d.score is None else round(d.score, 4)
+        out["checked"] = d.checked
+        out["prompt_sha256"] = d.prompt_hash
+        if d.error:
+            out["error"] = d.error
+    if isinstance(red, Redactors):
+        out["redacted"] = dict(red.found)
+    for key in ("upstream_status", "upstream_error"):
+        if key in state:
+            out[key] = state[key]
+    if "texts" in state:
+        out["texts"] = state["texts"]
+    return out
+
+
+class AuditLog:
+    def __init__(self, path: str) -> None:
+        self.path = Path(path) if path else None
+        self._lock = threading.Lock()
+
+    def write(self, rec: Json) -> None:
+        if self.path is None:
+            return
+        line = json.dumps(rec, ensure_ascii=False, default=str) + "\n"
+        with self._lock:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            with self.path.open("a", encoding="utf-8") as f:
+                f.write(line)
+
+
+def emit_span(rec: Json, started_ns: int) -> None:
+    """A span for the request, if OpenTelemetry is installed; otherwise nothing."""
+    try:
+        trace: Any = importlib.import_module("opentelemetry.trace")
+    except ImportError:
+        return
+    tracer: Any = trace.get_tracer("mobiusguard")
+    api = str(rec.get("api", ""))
+    span: Any = tracer.start_span(f"mobiusguard {api}", start_time=started_ns)
+    attrs: Json = {
+        "gen_ai.operation.name": "chat",
+        "gen_ai.system": SYSTEM.get(api, api),
+        "gen_ai.request.model": rec.get("model", ""),
+        "mobiusguard.decision": rec.get("decision", ""),
+        "mobiusguard.rules": [r["id"] for r in rec.get("rules", [])],
+        "mobiusguard.redacted": sum(rec.get("redacted", {}).values()),
+    }
+    if rec.get("score") is not None:
+        attrs["mobiusguard.score"] = rec["score"]
+    if "upstream_status" in rec:
+        attrs["http.response.status_code"] = rec["upstream_status"]
+    for k, v in attrs.items():
+        span.set_attribute(k, v)
+    span.end()

mobiusguard/classifier.py

@@ -0,0 +1,133 @@
+"""Optional pretrained prompt-injection classifiers (``mobiusguard[classifier]``).
+
+Pinned to a commit. PIGuard ships its model class as remote code; we never run downloaded
+code: the class is re-implemented below from the pinned ``modeling_piguard.py`` (a
+DeBERTa-v2 encoder, the first token's hidden state, one linear layer) and only the weights
+are downloaded. Scores are log-odds of the attack label (higher = more likely an attack).
+The evaluation harness measures this same code.
+"""
+
+from __future__ import annotations
+
+import importlib
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class HFModel:
+    name: str
+    repo: str
+    revision: str
+    licence: str
+    positive_label: str
+    arch: str = "auto"  # or "piguard"
+    max_length: int = 512
+
+
+HF_MODELS = {
+    "protectai-v2": HFModel(
+        name="protectai-v2",
+        repo="protectai/deberta-v3-base-prompt-injection-v2",
+        revision="90c9989b1a342275dd0d1a95aad283c04e075671",
+        licence="Apache-2.0",
+        positive_label="INJECTION",
+    ),
+    "piguard": HFModel(
+        name="piguard",
+        repo="leolee99/PIGuard",
+        revision="dd78b24e330193a22d2293ac66922dd4f982f563",
+        licence="MIT",
+        positive_label="injection",
+        arch="piguard",
+    ),
+}
+
+
+def _piguard_class(transformers: Any, torch: Any) -> Any:
+    outputs = importlib.import_module("transformers.modeling_outputs")
+
+    class PIGuard(transformers.DebertaV2ForSequenceClassification):
+        def __init__(self, config: Any) -> None:
+            super().__init__(config)  # pyright: ignore[reportUnknownMemberType]
+            self.classifier = torch.nn.Linear(config.hidden_size, config.num_labels)
+
+        def forward(self, input_ids: Any, attention_mask: Any, **kwargs: Any) -> Any:
+            out = self.deberta(input_ids=input_ids, attention_mask=attention_mask)
+            logits = self.classifier(out.last_hidden_state[:, 0, :])
+            return outputs.SequenceClassifierOutput(logits=logits)
+
+    return PIGuard
+
+
+class HFClassifier:
+    def __init__(self, spec: HFModel, *, device: str = "cpu", batch_size: int = 32) -> None:
+        self.spec = spec
+        self.name = spec.name
+        self.device = device
+        self.batch_size = batch_size
+        self.torch: Any = importlib.import_module("torch")
+        self.transformers: Any = importlib.import_module("transformers")
+        tf = self.transformers
+        self.tokenizer: Any = tf.AutoTokenizer.from_pretrained(
+            spec.repo, revision=spec.revision, trust_remote_code=False
+        )
+        if spec.arch == "piguard":
+            config = tf.DebertaV2Config.from_pretrained(
+                spec.repo, revision=spec.revision, trust_remote_code=False
+            )
+            cls = _piguard_class(tf, self.torch)
+            model = cls.from_pretrained(
+                spec.repo, revision=spec.revision, config=config, trust_remote_code=False
+            )
+        else:
+            model = tf.AutoModelForSequenceClassification.from_pretrained(
+                spec.repo, revision=spec.revision, trust_remote_code=False
+            )
+        self.model: Any = model.to(device).eval()
+        labels = {str(v).lower(): int(k) for k, v in self.model.config.id2label.items()}
+        self.positive = labels[spec.positive_label.lower()]
+
+    def info(self) -> dict[str, str]:
+        t = self.torch
+        info = {
+            "repo": self.spec.repo,
+            "revision": self.spec.revision,
+            "licence": self.spec.licence,
+            "device": self.device,
+            "torch": t.__version__,
+            "transformers": self.transformers.__version__,
+            "max_length": str(self.spec.max_length),
+            "score": "log-odds of the attack label",
+            "truncation": "longer inputs are cut to max_length tokens (the model card usage)",
+        }
+        if self.device.startswith("cuda"):
+            info["gpu"] = t.cuda.get_device_name(0)
+        else:
+            info["threads"] = str(t.get_num_threads())
+        return info
+
+    def score_texts(self, texts: Sequence[str]) -> list[float]:
+        t = self.torch
+        out: list[float] = []
+        with t.inference_mode():
+            for i in range(0, len(texts), self.batch_size):
+                enc = self.tokenizer(
+                    list(texts[i : i + self.batch_size]),
+                    truncation=True,
+                    max_length=self.spec.max_length,
+                    padding=True,
+                    return_tensors="pt",
+                ).to(self.device)
+                logits = self.model(
+                    input_ids=enc["input_ids"], attention_mask=enc["attention_mask"]
+                ).logits
+                # Log-odds of the positive label, not its probability: probabilities round to
+                # exactly 1.0 in float32 for confident inputs, and ties can't be thresholded.
+                lp = t.log_softmax(logits.double(), dim=-1)
+                rest = t.logsumexp(
+                    t.cat([lp[:, : self.positive], lp[:, self.positive + 1 :]], dim=-1), dim=-1
+                )
+                out.extend(float(v) for v in (lp[:, self.positive] - rest).cpu().tolist())
+        return out

mobiusguard/cli.py

@@ -0,0 +1,58 @@
+"""Command line: ``mobiusguard serve`` runs the proxy; ``mobiusguard check`` tries the guard.
+
+mobiusguard serve [--config mobiusguard.toml] [--host 127.0.0.1] [--port 8787]
+mobiusguard check "Ignore all previous instructions"
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from .apis import Text
+from .config import load
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="mobiusguard", description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)  # fmt: skip
+    sub = ap.add_subparsers(dest="command", required=True)
+    serve = sub.add_parser("serve", help="run the proxy")
+    serve.add_argument("--config", type=Path)
+    serve.add_argument("--host", default="127.0.0.1")
+    serve.add_argument("--port", type=int, default=8787)
+    chk = sub.add_parser("check", help="run the request check on a text and print the decision")
+    chk.add_argument("text", nargs="?", help="text to check (default: read stdin)")
+    chk.add_argument("--config", type=Path)
+    a = ap.parse_args(argv)
+    cfg = load(a.config)
+
+    if a.command == "check":
+        from .guard import Guard
+
+        text = a.text if a.text is not None else sys.stdin.read()
+        d = Guard(cfg).decide([Text("user", text, "input")])
+        print(json.dumps({"decision": d.action, "reason": d.reason, "score": d.score,
+                          "rules": [{"id": h.rule, "severity": h.severity, "view": h.view}
+                                    for h in d.hits]}, indent=2))  # fmt: skip
+        return 1 if d.action == "block" else 0
+
+    from .config import warnings
+
+    for w in warnings(cfg):
+        print(f"mobiusguard: warning: {w}", file=sys.stderr)
+
+    import uvicorn
+
+    from .app import create_app
+    from .hooks import ProxyHooks
+
+    uvicorn.run(create_app(cfg, hooks=ProxyHooks(cfg)), host=a.host, port=a.port)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())