pypproxy 0.1.0__py3-none-any.whl

pypproxy/ui/cui.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import asyncio
+
+from rich.console import Console
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from pypproxy.store.models import Entry
+from pypproxy.store.store import Store
+
+console = Console()
+
+METHOD_STYLES: dict[str, str] = {
+    "GET": "bold blue",
+    "POST": "bold green",
+    "PUT": "bold yellow",
+    "PATCH": "bold magenta",
+    "DELETE": "bold red",
+    "HEAD": "dim",
+    "OPTIONS": "dim",
+}
+
+
+def _method_text(method: str) -> Text:
+    style = METHOD_STYLES.get(method.upper(), "white")
+    return Text(method, style=style)
+
+
+def _status_text(code: int) -> Text:
+    if code == 0:
+        return Text("—", style="dim")
+    if 200 <= code < 300:
+        return Text(str(code), style="bold green")
+    if 300 <= code < 400:
+        return Text(str(code), style="bold cyan")
+    if 400 <= code < 500:
+        return Text(str(code), style="bold yellow")
+    return Text(str(code), style="bold red")
+
+
+def _build_table(entries: list[Entry]) -> Table:
+    table = Table(
+        show_header=True,
+        header_style="bold bright_white",
+        box=None,
+        padding=(0, 1),
+        expand=True,
+    )
+    table.add_column("ID", style="dim", width=6, justify="right")
+    table.add_column("Method", width=8, justify="center")
+    table.add_column("Host", min_width=20)
+    table.add_column("Path", min_width=30, no_wrap=False)
+    table.add_column("Status", width=7, justify="center")
+    table.add_column("ms", style="dim", width=6, justify="right")
+    table.add_column("Tags", style="dim", width=14)
+
+    for e in entries[:200]:
+        tags = ",".join(e.tags) if e.tags else ""
+        row_style = ""
+        if "blocked" in e.tags:
+            row_style = "on dark_red"
+        elif e.modified:
+            row_style = "on dark_orange3"
+
+        table.add_row(
+            str(e.id),
+            _method_text(e.method),
+            e.host,
+            e.path + (f"?{e.query}" if e.query else ""),
+            _status_text(e.status_code),
+            str(e.duration_ms) if e.duration_ms else "—",
+            tags,
+            style=row_style,
+        )
+    return table
+
+
+def _build_layout(entries: list[Entry], status: str) -> Layout:
+    layout = Layout()
+    layout.split_column(
+        Layout(name="header", size=3),
+        Layout(name="body"),
+        Layout(name="footer", size=1),
+    )
+
+    layout["header"].update(
+        Panel(
+            Text("paxy", style="bold white")
+            + Text("  MITM Proxy  ", style="dim")
+            + Text(f"[{len(entries)} requests]", style="cyan"),
+            style="on #1a1a2e",
+            border_style="bright_blue",
+        )
+    )
+
+    layout["body"].update(
+        Panel(
+            _build_table(entries),
+            title="[bold]Traffic[/bold]",
+            border_style="bright_blue",
+            padding=(0, 1),
+        )
+    )
+
+    layout["footer"].update(
+        Text(f"  {status}  q: quit  c: clear  /: filter", style="dim on #16213e")
+    )
+
+    return layout
+
+
+async def run_cui(store: Store, proxy_addr: str, ui_port: int) -> None:
+    entries: list[Entry] = []
+    status = f"proxy :{proxy_addr}  API :http://localhost:{ui_port}/api"
+    running = True
+
+    q = store.subscribe()
+
+    with Live(console=console, refresh_per_second=4, screen=True) as live:
+
+        async def _updater() -> None:
+            while running:
+                try:
+                    entry = q.get_nowait()
+                    entries.insert(0, entry)
+                except asyncio.QueueEmpty:
+                    pass
+                live.update(_build_layout(entries, status))
+                await asyncio.sleep(0.25)
+
+        async def _input_loop() -> None:
+            nonlocal running
+            loop = asyncio.get_event_loop()
+            import sys
+            import termios
+            import tty
+
+            fd = sys.stdin.fileno()
+            old = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)
+                while running:
+                    ch = await loop.run_in_executor(None, sys.stdin.read, 1)
+                    if ch in ("q", "Q", "\x03"):
+                        running = False
+                        break
+                    elif ch in ("c", "C"):
+                        store.clear()
+                        entries.clear()
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+        try:
+            await asyncio.gather(_updater(), _input_loop())
+        except (KeyboardInterrupt, asyncio.CancelledError):
+            pass
+        finally:
+            store.unsubscribe(q)

pypproxy/ui/detail.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import json
+
+from nicegui import ui
+
+from pypproxy.codec import decode_cbor, decode_msgpack, decode_protobuf_raw, sniff_content_type
+from pypproxy.store.models import Entry
+
+from .theme import method_badge, status_badge
+
+_VIEW_MODES = ["Auto", "Text", "JSON", "Hex", "Protobuf", "MessagePack", "CBOR"]
+
+
+def render_detail(entry: Entry | None, container: ui.element) -> None:
+    container.clear()
+    if entry is None:
+        with container:
+            ui.label("Select a request to inspect").classes("text-grey q-pa-md")
+        return
+
+    with container:
+        # --- request ---
+        with ui.expansion("Request", icon="upload", value=True).classes("w-full"):
+            with ui.row().classes("items-center q-mb-sm gap-2"):
+                method_badge(entry.method)
+                url = f"{entry.scheme}://{entry.host}{entry.path}"
+                if entry.query:
+                    url += "?" + entry.query
+                ui.label(url).classes("text-caption text-mono")
+
+            if entry.req_headers:
+                ui.label("Headers").classes("text-caption text-weight-bold q-mt-sm")
+                _render_headers(entry.req_headers)
+
+            if entry.req_body:
+                ui.label("Body").classes("text-caption text-weight-bold q-mt-sm")
+                ct = entry.req_headers.get("content-type", [""])[0]
+                _render_body_with_selector(entry.req_body, ct)
+
+        ui.separator()
+
+        # --- response ---
+        with ui.expansion("Response", icon="download", value=True).classes("w-full"):
+            if entry.status_code:
+                with ui.row().classes("items-center gap-2 q-mb-sm"):
+                    status_badge(entry.status_code)
+                    ui.label(f"{entry.duration_ms} ms").classes("text-caption text-grey")
+
+            if entry.resp_headers:
+                ui.label("Headers").classes("text-caption text-weight-bold q-mt-sm")
+                _render_headers(entry.resp_headers)
+
+            if entry.resp_body:
+                ui.label("Body").classes("text-caption text-weight-bold q-mt-sm")
+                ct = entry.resp_headers.get("content-type", [""])[0]
+                _render_body_with_selector(entry.resp_body, ct)
+
+        ui.separator()
+
+        # --- replay ---
+        with ui.row().classes("q-pa-sm"):
+            ui.button("Replay", icon="replay", on_click=lambda: _replay(entry)).props(
+                "color=primary size=sm"
+            )
+
+
+def _render_body_with_selector(raw: bytes, content_type: str) -> None:
+    sniffed = sniff_content_type(raw, content_type)
+    default_mode = {
+        "json": "JSON",
+        "proto": "Protobuf",
+        "msgpack": "MessagePack",
+        "cbor": "CBOR",
+        "binary": "Hex",
+    }.get(sniffed, "Auto")
+
+    body_area = ui.element("div").classes("w-full")
+
+    def _update(mode: str) -> None:
+        body_area.clear()
+        with body_area:
+            text = _decode_as(raw, mode, content_type)
+            ui.element("pre").classes("paxy-body-pre").text = text
+
+    with ui.row().classes("items-center gap-2 q-mb-xs"):
+        view_select = (
+            ui.select(_VIEW_MODES, value=default_mode, label="View")
+            .props("dense outlined dark")
+            .classes("w-32")
+        )
+        view_select.on("update:model-value", lambda e: _update(e.args))
+
+    _update(default_mode)
+
+
+def _decode_as(raw: bytes, mode: str, content_type: str) -> str:
+    if mode == "Hex":
+        return _to_hex(raw)
+    if mode == "Protobuf":
+        return decode_protobuf_raw(raw)
+    if mode == "MessagePack":
+        return decode_msgpack(raw)
+    if mode == "CBOR":
+        return decode_cbor(raw)
+    if mode == "JSON":
+        try:
+            return json.dumps(
+                json.loads(raw.decode("utf-8", errors="replace")), indent=2, ensure_ascii=False
+            )
+        except Exception:
+            return raw.decode("utf-8", errors="replace")
+    if mode == "Text":
+        return raw.decode("utf-8", errors="replace")
+    # Auto
+    return _smart_decode(raw, content_type)
+
+
+def _smart_decode(raw: bytes, content_type: str) -> str:
+    sniffed = sniff_content_type(raw, content_type)
+    if sniffed == "json":
+        try:
+            return json.dumps(
+                json.loads(raw.decode("utf-8", errors="replace")), indent=2, ensure_ascii=False
+            )
+        except Exception:
+            pass
+    if sniffed == "proto":
+        return decode_protobuf_raw(raw)
+    if sniffed == "msgpack":
+        return decode_msgpack(raw)
+    if sniffed == "cbor":
+        return decode_cbor(raw)
+    if sniffed == "binary":
+        return _to_hex(raw)
+    try:
+        return raw.decode("utf-8", errors="replace")
+    except Exception:
+        return _to_hex(raw)
+
+
+def _to_hex(raw: bytes) -> str:
+    lines: list[str] = []
+    for i in range(0, len(raw), 16):
+        chunk = raw[i : i + 16]
+        hex_part = " ".join(f"{b:02x}" for b in chunk)
+        ascii_part = "".join(chr(b) if 0x20 <= b < 0x7F else "." for b in chunk)
+        lines.append(f"{i:08x}  {hex_part:<47}  {ascii_part}")
+    return "\n".join(lines)
+
+
+def _render_headers(headers: dict[str, list[str]]) -> None:
+    with ui.element("table").classes("paxy-header-table w-full"):
+        for k, vs in sorted(headers.items()):
+            with ui.element("tr"):
+                ui.element("td").style(
+                    "color:#aaa; min-width:160px; padding:2px 8px; font-size:12px"
+                ).text = k
+                ui.element("td").style("padding:2px 8px; font-size:12px").text = ", ".join(vs)
+
+
+async def _replay(entry: Entry) -> None:
+    import httpx
+
+    url = f"{entry.scheme}://{entry.host}{entry.path}"
+    if entry.query:
+        url += "?" + entry.query
+    headers = {k: ", ".join(v) for k, v in entry.req_headers.items()}
+    try:
+        async with httpx.AsyncClient(verify=False, timeout=30, http2=True) as client:
+            resp = await client.request(
+                method=entry.method,
+                url=url,
+                headers=headers,
+                content=entry.req_body,
+            )
+        ui.notify(f"Replay: {resp.status_code} ({len(resp.content)} bytes)", type="positive")
+    except Exception as e:
+        ui.notify(f"Replay failed: {e}", type="negative")

pypproxy/ui/diff_view.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import difflib
+
+from nicegui import ui
+
+from pypproxy.store.models import Entry
+
+
+def build_diff_view(container: ui.element) -> dict:
+    """Build the diff view UI inside container. Returns state dict with set_entries method."""
+    state: dict = {"left": None, "right": None}
+
+    container.clear()
+    with container:
+        ui.label("Diff View").classes("text-subtitle2 q-mb-sm")
+        ui.label("Select two entries from the traffic list (right-click → Compare)").classes(
+            "text-grey text-caption"
+        )
+        diff_container = ui.element("div").classes("w-full")
+
+    def set_entries(left: Entry, right: Entry) -> None:
+        state["left"] = left
+        state["right"] = right
+        _render_diff(left, right, diff_container)
+
+    return {"set_entries": set_entries}
+
+
+def _render_diff(left: Entry, right: Entry, container: ui.element) -> None:
+    container.clear()
+    with container:
+        with ui.tabs() as tabs:
+            req_tab = ui.tab("Request")
+            resp_tab = ui.tab("Response")
+            headers_tab = ui.tab("Headers")
+
+        with ui.tab_panels(tabs, value=req_tab).classes("w-full"):
+            with ui.tab_panel(req_tab):
+                _render_text_diff(
+                    _entry_req_text(left),
+                    _entry_req_text(right),
+                    f"#{left.id} {left.method} {left.path}",
+                    f"#{right.id} {right.method} {right.path}",
+                )
+            with ui.tab_panel(resp_tab):
+                _render_text_diff(
+                    _decode(left.resp_body),
+                    _decode(right.resp_body),
+                    f"#{left.id} {left.status_code}",
+                    f"#{right.id} {right.status_code}",
+                )
+            with ui.tab_panel(headers_tab):
+                _render_text_diff(
+                    _headers_text(left.req_headers),
+                    _headers_text(right.req_headers),
+                    f"#{left.id} req headers",
+                    f"#{right.id} req headers",
+                )
+
+
+def _render_text_diff(a: str, b: str, label_a: str, label_b: str) -> None:
+    diff = list(
+        difflib.unified_diff(
+            a.splitlines(keepends=True),
+            b.splitlines(keepends=True),
+            fromfile=label_a,
+            tofile=label_b,
+            lineterm="",
+        )
+    )
+
+    if not diff:
+        ui.label("No differences").classes("text-grey q-pa-sm")
+        return
+
+    html_parts: list[str] = []
+    for line in diff:
+        if line.startswith("+++") or line.startswith("---") or line.startswith("@@"):
+            cls = "color:#888"
+        elif line.startswith("+"):
+            cls = "color:#4caf50;background:#1b2e1b"
+        elif line.startswith("-"):
+            cls = "color:#f44336;background:#2e1b1b"
+        else:
+            cls = "color:#ccc"
+        escaped = line.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        html_parts.append(f'<span style="{cls}">{escaped}</span>')
+
+    html = (
+        "<pre style='font-size:12px;line-height:1.4;overflow:auto;padding:8px;background:#111'>"
+        + "\n".join(html_parts)
+        + "</pre>"
+    )
+    ui.html(html).classes("w-full")
+
+
+def _entry_req_text(e: Entry) -> str:
+    parts = [f"{e.method} {e.path} HTTP/1.1", f"Host: {e.host}"]
+    for k, vs in e.req_headers.items():
+        parts.append(f"{k}: {', '.join(vs)}")
+    parts.append("")
+    if e.req_body:
+        parts.append(_decode(e.req_body))
+    return "\n".join(parts)
+
+
+def _headers_text(headers: dict) -> str:
+    return "\n".join(f"{k}: {', '.join(v)}" for k, v in sorted(headers.items()))
+
+
+def _decode(b: bytes) -> str:
+    if not b:
+        return ""
+    try:
+        return b.decode("utf-8", errors="replace")
+    except Exception:
+        return b.hex()