omna-plugin 0.6.0__py3-none-any.whl

omna_plugin/__main__.py

@@ -0,0 +1,16 @@
+"""Entry point for `python -m omna_plugin` and for the bundled binary.
+
+The console script in pyproject.toml points at ``cli:main``; PyInstaller needs
+a real module to start from, and having one also makes ``python -m omna_plugin``
+work, which the daemon already relies on when it re-spawns itself.
+
+The import is ABSOLUTE on purpose: PyInstaller runs this file as a top-level
+script, where a relative import has no parent package and fails at startup.
+"""
+
+import sys
+
+from omna_plugin.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

omna_plugin/adapters/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from .base import SiteAdapter
+from .generic import GenericAdapter
+
+_GENERIC = GenericAdapter()
+_REGISTRY: list[SiteAdapter] = []   # site adapters register themselves (a later task, not yours)
+
+
+def register(adapter: SiteAdapter) -> None:
+    _REGISTRY.append(adapter)
+
+
+def for_host(host: str) -> SiteAdapter:
+    h = (host or "").lower().rsplit(":", 1)[0]
+    for a in _REGISTRY:
+        if any(h == s or h.endswith("." + s) for s in a.hosts):
+            return a
+    return _GENERIC

omna_plugin/adapters/base.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Literal, Protocol
+
+from ..pipeline import MaskStats, Pipeline
+
+# Same rule the Chrome extension uses to decide "this POST carries a prompt".
+ENDPOINT_RE = re.compile(
+    r"/(append_message|completion|conversation|stream|chat|generate|backend-api|message|messages|prompt|responses|complete|embeddings)",
+    re.I,
+)
+
+ResponseMode = Literal["stream-json", "stream-text", "json", "passthrough"]
+
+
+@dataclass
+class RequestView:
+    host: str
+    method: str
+    path: str
+    content_type: str
+    body: bytes
+    headers: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class MaskOutcome:
+    body: bytes | None            # the masked body to forward (None = forward original, or refused)
+    stats: MaskStats
+    refused: str | None = None    # set → do NOT forward; answer 400
+    passthrough: bool = False     # forwarded unchanged on purpose (not a prompt)
+
+
+class SiteAdapter(Protocol):
+    name: str
+    hosts: tuple[str, ...]
+
+    def is_prompt(self, req: RequestView) -> bool: ...
+    def mask(self, pipeline: Pipeline, req: RequestView) -> MaskOutcome: ...
+    def response_mode(self, content_type: str) -> ResponseMode: ...

omna_plugin/adapters/generic.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from ..pipeline import MaskStats, Pipeline
+from .base import ENDPOINT_RE, MaskOutcome, RequestView, ResponseMode
+
+_MASKABLE = ("json", "x-www-form-urlencoded", "text/")
+
+
+class GenericAdapter:
+    """Default for every AI host: mask every prose string in a prompt body; refuse what we cannot parse."""
+
+    name = "generic"
+    hosts: tuple[str, ...] = ()
+
+    def is_prompt(self, req: RequestView) -> bool:
+        return req.method in ("POST", "PUT", "PATCH") and ENDPOINT_RE.search(req.path) is not None
+
+    def mask(self, pipeline: Pipeline, req: RequestView) -> MaskOutcome:
+        ct = (req.content_type or "").lower()
+        maskable = any(m in ct for m in _MASKABLE)
+        if not self.is_prompt(req):
+            if maskable and req.body:
+                out = pipeline.mask_bytes(req.body, ct)     # best effort on non-prompt text; never refuse
+                if out.refused is None:
+                    return MaskOutcome(out.body, out.stats)
+            return MaskOutcome(None, MaskStats(), passthrough=True)
+        if not req.body:
+            return MaskOutcome(None, MaskStats(), passthrough=True)
+        if not maskable:
+            return MaskOutcome(None, MaskStats(), refused="unparseable")
+        out = pipeline.mask_bytes(req.body, ct)
+        return MaskOutcome(out.body, out.stats, refused=out.refused)
+
+    def response_mode(self, content_type: str) -> ResponseMode:
+        ct = (content_type or "").lower()
+        if "event-stream" in ct or "x-ndjson" in ct:
+            return "stream-json"
+        if "json" in ct:
+            return "json"
+        if ct.startswith("text/"):
+            return "stream-text"
+        return "passthrough"

omna_plugin/aider.py

@@ -0,0 +1,147 @@
+"""Wire aider to the proxy by editing its own config files.
+
+aider reads two different places depending on which provider you're using:
+- OpenAI: the ``openai-api-base`` key in ``~/.aider.conf.yml``, aider's own
+  dedicated config file (https://aider.chat/docs/config/aider_conf.html).
+- Anthropic/Claude: aider runs on litellm underneath, which honours the
+  standard ``ANTHROPIC_BASE_URL`` environment variable directly; aider itself
+  has no YAML key for this. Rather than touch the person's shell profile
+  (which affects every program in every terminal — the exact mistake that
+  caused real, hours-long confusion earlier today, 2026-09-19), we set it in
+  aider's own auto-loaded ``~/.env`` instead
+  (https://aider.chat/docs/config/dotenv.html) — the officially documented
+  mechanism for exactly this, and scoped to aider (and anything else that
+  chooses to read that file), not every terminal session on the machine.
+
+Both files are edited as marked lines, not round-tripped through a YAML or
+dotenv library, so any other settings a person already has stay untouched.
+The ``.env`` edit puts its marker on its own comment line above the value
+(rather than a trailing inline comment) since dotenv parsers vary on whether
+an inline ``#`` after an unquoted value is treated as a comment or as part of
+the value — getting that wrong here would silently point aider at a broken
+address instead of Omna, an easy way to end up sending things unmasked.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+from pathlib import Path
+
+from . import config
+
+MARK = "# added by omna"
+_YAML_KEY_RE = re.compile(r'^openai-api-base:.*$', re.MULTILINE)
+_ENV_BLOCK_RE = re.compile(rf'^{re.escape(MARK)}\nANTHROPIC_BASE_URL=.*$', re.MULTILINE)
+_ENV_KEY_RE = re.compile(r'^ANTHROPIC_BASE_URL=.*$', re.MULTILINE)
+
+
+def conf_file() -> Path:
+    return Path.home() / ".aider.conf.yml"
+
+
+def env_file() -> Path:
+    return Path.home() / ".env"
+
+
+def _backup(path: Path, changes: dict, key: str) -> None:
+    if path.exists():
+        backup = path.with_name(path.name + ".omna-backup")
+        if not backup.exists():
+            shutil.copyfile(path, backup)
+            changes[key] = str(backup)
+
+
+def _set_yaml_key(port: int, changes: dict) -> None:
+    path = conf_file()
+    text = path.read_text() if path.exists() else ""
+    new_line = f'openai-api-base: "{config.base_url(port)}/v1"  {MARK}'
+    existing = _YAML_KEY_RE.search(text)
+    if existing and MARK not in existing.group(0):
+        return  # someone set this deliberately; don't fight it silently
+    _backup(path, changes, "openai_backup")
+    if existing:
+        if existing.group(0).strip() == new_line.strip():
+            return
+        text = _YAML_KEY_RE.sub(new_line, text, count=1)
+    else:
+        sep = "" if not text or text.endswith("\n") else "\n"
+        text = f"{text}{sep}{new_line}\n"
+    path.write_text(text)
+    changes["openai_base"] = True
+
+
+def _set_env_block(port: int, changes: dict) -> None:
+    path = env_file()
+    text = path.read_text() if path.exists() else ""
+    _backup(path, changes, "anthropic_backup")
+    new_block = f"{MARK}\nANTHROPIC_BASE_URL={config.base_url(port)}"
+    existing = _ENV_BLOCK_RE.search(text)
+    if existing:
+        if existing.group(0).strip() == new_block.strip():
+            return
+        text = _ENV_BLOCK_RE.sub(new_block, text, count=1)
+    elif _ENV_KEY_RE.search(text):
+        # a value we didn't set (no marker line above it) — leave it alone,
+        # someone configured this deliberately; don't fight it silently.
+        return
+    else:
+        sep = "" if not text or text.endswith("\n") else "\n"
+        text = f"{text}{sep}{new_block}\n"
+    path.write_text(text)
+    changes["anthropic_base"] = True
+
+
+def init(port: int = config.DEFAULT_PORT) -> dict:
+    changes = {"openai_base": False, "anthropic_base": False, "openai_backup": None, "anthropic_backup": None}
+    _set_yaml_key(port, changes)
+    _set_env_block(port, changes)
+    return changes
+
+
+def uninstall() -> dict:
+    """Remove exactly what ``init`` added; leave everything else untouched."""
+    changes = {"openai_base": False, "anthropic_base": False, "openai_backup": False, "anthropic_backup": False}
+
+    conf = conf_file()
+    conf_backup = conf.with_name(conf.name + ".omna-backup")
+    if conf_backup.exists():
+        conf_backup.unlink()
+        changes["openai_backup"] = True
+    if conf.exists():
+        text = conf.read_text()
+        m = _YAML_KEY_RE.search(text)
+        if m and MARK in m.group(0):
+            text = _YAML_KEY_RE.sub("", text, count=1)
+            text = re.sub(r"\n{3,}", "\n\n", text)
+            conf.write_text(text)
+            changes["openai_base"] = True
+
+    env = env_file()
+    env_backup = env.with_name(env.name + ".omna-backup")
+    if env_backup.exists():
+        env_backup.unlink()
+        changes["anthropic_backup"] = True
+    if env.exists():
+        text = env.read_text()
+        m = _ENV_BLOCK_RE.search(text)
+        if m:
+            text = _ENV_BLOCK_RE.sub("", text, count=1)
+            text = re.sub(r"\n{3,}", "\n\n", text)
+            env.write_text(text)
+            changes["anthropic_base"] = True
+
+    return changes
+
+
+def status() -> dict:
+    conf_text = conf_file().read_text() if conf_file().exists() else ""
+    env_text = env_file().read_text() if env_file().exists() else ""
+    m1 = _YAML_KEY_RE.search(conf_text)
+    m2 = _ENV_BLOCK_RE.search(env_text)
+    return {
+        "openai_base_file": str(conf_file()),
+        "openai_base": m1.group(0).split(":", 1)[1].split(MARK)[0].strip().strip('"') if m1 else None,
+        "anthropic_base_file": str(env_file()),
+        "anthropic_base": m2.group(0).splitlines()[1].split("=", 1)[1].strip() if m2 else None,
+    }

omna_plugin/body.py

@@ -0,0 +1,94 @@
+"""Walk JSON request/response bodies, masking or restoring the human text.
+
+Generic on purpose: Anthropic Messages, OpenAI chat completions and the OpenAI
+Responses API all put text in nested dicts/lists. We mask every string value
+except the ones that must stay byte-identical (signatures, thinking blocks,
+base64 media, tool schemas, config fields) and skip anything that looks like a
+binary blob.
+"""
+
+from __future__ import annotations
+
+import re
+
+from .engine import MaskingSession
+
+# Keys whose values are never human prose, or must reach the upstream untouched.
+SKIP_KEYS = frozenset(
+    {
+        # identity / config
+        "id", "model", "type", "role", "name", "tool_use_id", "tool_call_id",
+        "call_id", "media_type", "stop_reason", "stop_sequence", "stop_sequences",
+        "url", "file_id", "service_tier", "anthropic_version", "stream",
+        "tool_choice", "output_config", "context_management",
+        "mcp_servers", "container", "response_format", "modalities", "user",
+        # must be byte-identical for the API to accept the request back
+        "signature", "thinking", "redacted_thinking", "cache_control",
+        # binary / opaque
+        "data", "image_url", "b64_json", "encrypted_content",
+        # tool definitions are schemas, not prose
+        "tools", "functions", "input_schema", "parameters",
+    }
+)
+
+# Long runs with no whitespace and only base64 characters: media, not prose.
+_BLOB_RE = re.compile(r"^[A-Za-z0-9+/=_\-]{256,}$")
+
+
+def _is_blob(s: str) -> bool:
+    return len(s) >= 256 and _BLOB_RE.match(s) is not None
+
+
+def _walk(obj, fn, counts: dict[str, int], key: str | None = None):
+    if isinstance(obj, str):
+        if key in SKIP_KEYS or _is_blob(obj):
+            return obj
+        return fn(obj, counts)
+    if isinstance(obj, list):
+        if key in SKIP_KEYS:
+            return obj
+        return [_walk(item, fn, counts, key) for item in obj]
+    if isinstance(obj, dict):
+        if key in SKIP_KEYS:
+            return obj
+        out = {}
+        for k, v in obj.items():
+            out[k] = _walk(v, fn, counts, k)
+        return out
+    return obj
+
+
+def mask_body(session: MaskingSession, obj):
+    """Return (masked_copy, counts). ``obj`` is not modified.
+
+    ``counts`` maps entity name -> occurrences and carries reserved keys that
+    the receipt writer pops off: ``_secrets`` / ``_pii`` (totals by layer),
+    ``_validated`` (catches a checksum actually proved) and ``_layer_L1`` etc.
+    """
+    counts: dict[str, int] = {}
+
+    def fn(s: str, c: dict[str, int]) -> str:
+        r = session.mask_text(s)
+        for k, n in r.counts.items():
+            c[k] = c.get(k, 0) + n
+        if r.secrets:
+            c["_secrets"] = c.get("_secrets", 0) + r.secrets
+        if r.pii:
+            c["_pii"] = c.get("_pii", 0) + r.pii
+        if r.validated:
+            c["_validated"] = c.get("_validated", 0) + r.validated
+        for layer, n in r.by_layer.items():
+            k = f"_layer_{layer}"
+            c[k] = c.get(k, 0) + n
+        return r.masked
+
+    return _walk(obj, fn, counts), counts
+
+
+def restore_body(session: MaskingSession, obj):
+    """Return a copy with every reversible token replaced by its real value."""
+
+    def fn(s: str, _c) -> str:
+        return session.restore_text(s)
+
+    return _walk(obj, fn, {})

omna_plugin/claude_code.py

@@ -0,0 +1,120 @@
+"""Wire Claude Code to the proxy by editing its ``settings.json``.
+
+Claude Code reads an ``env`` block from its settings, so we set
+``ANTHROPIC_BASE_URL`` there (no shell-profile edits) and add a ``SessionStart``
+hook that runs ``omna ensure`` so the proxy is started on demand. Both edits are
+marked and reversible; ``uninstall`` removes only what ``init`` added.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+from pathlib import Path
+
+from . import config
+
+ENV_KEY = "ANTHROPIC_BASE_URL"
+HOOK_MARK = "omna ensure"
+
+
+def settings_file(scope: str = "user") -> Path:
+    if scope == "project":
+        return Path.cwd() / ".claude" / "settings.json"
+    return Path.home() / ".claude" / "settings.json"
+
+
+def _load(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text() or "{}")
+    except ValueError as e:
+        raise SystemExit(f"omna: {path} is not valid JSON ({e}); fix it first, nothing was changed")
+
+
+def _omna_command() -> str:
+    """Absolute command for the hook, so it works even if ~/.local/bin is not on PATH."""
+    exe = shutil.which("omna")
+    if exe:
+        return f'"{exe}" ensure' if " " in exe else f"{exe} ensure"
+    return f'"{sys.executable}" -m omna_plugin.cli ensure'
+
+
+def _is_ours(hook: dict) -> bool:
+    cmd = str(hook.get("command", "")).strip()
+    return "omna" in cmd and cmd.endswith(" ensure")
+
+
+def init(path: Path, port: int = config.DEFAULT_PORT) -> dict:
+    """Add our env var + SessionStart hook. Returns what changed."""
+    data = _load(path)
+    changes = {"backup": None, "env": False, "hook": False}
+    if path.exists():
+        backup = path.with_name(path.name + ".omna-backup")
+        if not backup.exists():
+            shutil.copyfile(path, backup)
+            changes["backup"] = str(backup)
+    env = data.setdefault("env", {})
+    url = config.base_url(port)
+    if env.get(ENV_KEY) != url:
+        env[ENV_KEY] = url
+        changes["env"] = True
+    hooks = data.setdefault("hooks", {})
+    starts = hooks.setdefault("SessionStart", [])
+    already = any(_is_ours(h) for entry in starts for h in entry.get("hooks", []))
+    if not already:
+        starts.append({"hooks": [{"type": "command", "command": _omna_command(), "timeout": 30}]})
+        changes["hook"] = True
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    return changes
+
+
+def uninstall(path: Path) -> dict:
+    """Remove exactly what ``init`` added; leave everything else untouched."""
+    changes = {"env": False, "hook": False, "backup": False}
+    backup = path.with_name(path.name + ".omna-backup")
+    if backup.exists():
+        backup.unlink()
+        changes["backup"] = True
+    if not path.exists():
+        return changes
+    data = _load(path)
+    env = data.get("env") or {}
+    if isinstance(env.get(ENV_KEY), str) and env[ENV_KEY].startswith(f"http://{config.DEFAULT_HOST}:"):
+        del env[ENV_KEY]
+        changes["env"] = True
+        if not env:
+            data.pop("env", None)
+    hooks = data.get("hooks") or {}
+    starts = hooks.get("SessionStart") or []
+    kept = []
+    for entry in starts:
+        inner = [h for h in entry.get("hooks", []) if not _is_ours(h)]
+        if len(inner) != len(entry.get("hooks", [])):
+            changes["hook"] = True
+        if inner:
+            entry = dict(entry, hooks=inner)
+            kept.append(entry)
+    if starts:
+        if kept:
+            hooks["SessionStart"] = kept
+        else:
+            hooks.pop("SessionStart", None)
+        if not hooks:
+            data.pop("hooks", None)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    return changes
+
+
+def status(path: Path) -> dict:
+    data = _load(path) if path.exists() else {}
+    env = data.get("env") or {}
+    starts = (data.get("hooks") or {}).get("SessionStart") or []
+    return {
+        "file": str(path),
+        "base_url": env.get(ENV_KEY),
+        "hook": any(_is_ours(h) for e in starts for h in e.get("hooks", [])),
+    }