pypproxy 0.1.0__py3-none-any.whl

pypproxy/ui/graphql_tab.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+import json
+
+from nicegui import ui
+
+from pypproxy.store.models import Entry
+from pypproxy.store.store import Store
+
+
+def build_graphql_tab(store: Store) -> dict:
+    """Build the GraphQL tab. Returns state with open_entry method."""
+    state: dict = {"entry": None, "schema": None}
+
+    with ui.column().classes("w-full h-full overflow-auto q-pa-md"):
+        # --- Introspection section ---
+        with ui.expansion("Schema Introspection", icon="schema", value=True).classes(
+            "w-full q-mb-md"
+        ):
+            ui.label("Fetch the GraphQL schema from an endpoint using introspection.").classes(
+                "text-caption text-grey q-mb-sm"
+            )
+
+            with ui.row().classes("gap-2 items-center w-full"):
+                url_input = (
+                    ui.input(
+                        label="GraphQL endpoint URL", placeholder="https://api.example.com/graphql"
+                    )
+                    .props("dense outlined dark")
+                    .classes("flex-1")
+                )
+                introspect_btn = ui.button("Introspect", icon="search").props(
+                    "color=primary size=sm"
+                )
+
+            schema_status = ui.label("").classes("text-caption text-grey q-mt-xs")
+
+            schema_tree = (
+                ui.tree(
+                    [],
+                    label_key="label",
+                    children_key="children",
+                )
+                .props("dark dense")
+                .classes("w-full q-mt-sm")
+            )
+
+            async def _introspect() -> None:
+                url = url_input.value.strip()
+                if not url:
+                    ui.notify("Enter a URL", type="warning")
+                    return
+                introspect_btn.props("loading")
+                try:
+                    from pypproxy.graphql.introspection import fetch_schema
+
+                    req_headers: dict[str, str] = {}
+                    entry = state.get("entry")
+                    if entry:
+                        req_headers = {
+                            k: ", ".join(v)
+                            for k, v in entry.req_headers.items()
+                            if k.lower() not in ("content-length",)
+                        }
+
+                    schema = await fetch_schema(url, req_headers)
+                    if schema is None:
+                        ui.notify("Introspection failed or not supported", type="negative")
+                        return
+
+                    state["schema"] = schema
+                    schema_status.text = (
+                        f"Schema loaded: {len(schema.types)} types, "
+                        f"Query: {schema.query_type}, Mutation: {schema.mutation_type}"
+                    )
+
+                    # Build tree
+                    nodes = []
+                    for t in schema.types:
+                        if t.name.startswith("__") or not t.fields:
+                            continue
+                        children = [
+                            {"id": f"{t.name}.{f.name}", "label": f"{f.name}: {f.type_name}"}
+                            for f in t.fields
+                        ]
+                        nodes.append(
+                            {
+                                "id": t.name,
+                                "label": f"{t.name} ({t.kind})",
+                                "children": children,
+                            }
+                        )
+                    schema_tree.nodes = nodes
+                    schema_tree.update()
+                    ui.notify(f"Schema loaded: {len(schema.types)} types", type="positive")
+                finally:
+                    introspect_btn.props(remove="loading")
+
+            introspect_btn.on("click", _introspect)
+
+        # --- Query editor ---
+        with ui.expansion("Query Editor", icon="code", value=True).classes("w-full q-mb-md"):
+            entry_label = ui.label("No entry selected").classes("text-caption text-grey q-mb-xs")
+
+            with ui.row().classes("gap-2 items-center q-mb-xs"):
+                op_type_badge = ui.badge("", color="grey").props("rounded")
+                op_name_label = ui.label("").classes("text-caption")
+
+            query_input = (
+                ui.textarea(placeholder="query { ... }\n\nOr paste a GraphQL query here")
+                .props("outlined dense rows=8")
+                .classes("w-full font-mono text-xs")
+            )
+
+            ui.label("Variables (JSON):").classes("text-caption q-mt-xs")
+            vars_input = (
+                ui.textarea(placeholder='{"id": "123"}')
+                .props("outlined dense rows=3")
+                .classes("w-full font-mono text-xs")
+            )
+
+            run_btn = ui.button("Run Query", icon="play_arrow").props("color=primary")
+            result_label = ui.label("").classes("text-caption text-grey q-mt-xs")
+            result_area = (
+                ui.textarea()
+                .props("outlined dense rows=10 readonly")
+                .classes("w-full font-mono text-xs q-mt-xs")
+            )
+
+            async def _run_query() -> None:
+                entry = state.get("entry")
+                if not entry:
+                    ui.notify(
+                        "No entry selected — right-click a GraphQL request in Traffic",
+                        type="warning",
+                    )
+                    return
+
+                import httpx
+
+                url = f"{entry.scheme}://{entry.host}{entry.path}"
+                req_headers = {
+                    k: ", ".join(v)
+                    for k, v in entry.req_headers.items()
+                    if k.lower() not in ("content-length",)
+                }
+
+                query = query_input.value.strip()
+                if not query:
+                    ui.notify("Enter a query", type="warning")
+                    return
+
+                variables: dict = {}
+                if vars_input.value.strip():
+                    try:
+                        variables = json.loads(vars_input.value)
+                    except Exception:
+                        ui.notify("Variables must be valid JSON", type="warning")
+                        return
+
+                run_btn.props("loading")
+                try:
+                    async with httpx.AsyncClient(verify=False, timeout=30, http2=True) as client:
+                        resp = await client.post(
+                            url,
+                            json={"query": query, "variables": variables},
+                            headers=req_headers,
+                        )
+                    try:
+                        body = json.dumps(resp.json(), indent=2, ensure_ascii=False)
+                    except Exception:
+                        body = resp.text
+                    result_label.text = f"Status: {resp.status_code}"
+                    result_area.value = body
+                    ui.notify(
+                        f"{resp.status_code}",
+                        type="positive" if resp.status_code < 400 else "warning",
+                    )
+                except Exception as e:
+                    result_area.value = str(e)
+                    ui.notify(str(e), type="negative")
+                finally:
+                    run_btn.props(remove="loading")
+
+            run_btn.on("click", _run_query)
+
+        # --- Operation analysis ---
+        with ui.expansion("Operation Analysis", icon="analytics").classes("w-full"):
+            ui.label("Analyse a captured GraphQL request.").classes(
+                "text-caption text-grey q-mb-sm"
+            )
+
+            analyse_btn = ui.button("Analyse selected entry", icon="analytics").props(
+                "color=secondary size=sm"
+            )
+            analysis_area = (
+                ui.textarea()
+                .props("outlined dense rows=12 readonly")
+                .classes("w-full font-mono text-xs q-mt-xs")
+            )
+
+            def _analyse() -> None:
+                entry = state.get("entry")
+                if not entry or "graphql" not in entry.tags:
+                    ui.notify("Select a GraphQL entry from Traffic", type="warning")
+                    return
+
+                from pypproxy.graphql.detector import (
+                    extract_field_names,
+                    extract_operation_name,
+                    extract_operation_type,
+                    parse_operation,
+                )
+
+                op = parse_operation(entry.req_body)
+                query = op.get("query", "")
+                lines = [
+                    f"Operation type : {extract_operation_type(query)}",
+                    f"Operation name : {extract_operation_name(query) or '(anonymous)'}",
+                    f"Fields detected: {', '.join(extract_field_names(query)) or '(none)'}",
+                    "",
+                    "--- Variables ---",
+                    json.dumps(op.get("variables", {}), indent=2),
+                    "",
+                    "--- Query ---",
+                    query,
+                ]
+                analysis_area.value = "\n".join(lines)
+
+                # Try to find schema for this host
+                schema = state.get("schema")
+                if schema:
+                    root = schema.root_fields()
+                    lines.append("")
+                    lines.append(f"--- Schema root fields ({schema.query_type}) ---")
+                    lines.extend(f"  {f.name}: {f.type_name}" for f in root)
+                    analysis_area.value = "\n".join(lines)
+
+            analyse_btn.on("click", _analyse)
+
+    def open_entry(entry: Entry) -> None:
+        state["entry"] = entry
+        entry_label.text = f"#{entry.id} {entry.method} {entry.scheme}://{entry.host}{entry.path}"
+        op_type_badge.text = entry.graphql_op_type or ""
+        op_name_label.text = entry.graphql_operation or ""
+        if entry.graphql_op_type == "mutation":
+            op_type_badge.props("color=warning")
+        elif entry.graphql_op_type == "subscription":
+            op_type_badge.props("color=info")
+        else:
+            op_type_badge.props("color=positive")
+
+        # Auto-fill query and variables from entry
+        from pypproxy.graphql.detector import parse_operation
+
+        op = parse_operation(entry.req_body)
+        query_input.value = op.get("query", "")
+        vars_input.value = (
+            json.dumps(op.get("variables", {}), indent=2) if op.get("variables") else ""
+        )
+
+        # Auto-set introspection URL
+        url_input.value = f"{entry.scheme}://{entry.host}{entry.path}"
+
+    return {"open_entry": open_entry}

pypproxy/ui/import_tab.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from nicegui import ui
+
+from pypproxy.store.store import Store
+
+
+def build_import_tab(store: Store) -> None:
+    """Build the Import tab content."""
+    with ui.column().classes("w-full h-full overflow-auto q-pa-md"):
+        ui.label("Import Traffic").classes("text-subtitle2 q-mb-sm")
+
+        # --- File upload ---
+        ui.label("Upload HAR or paxy JSON file:").classes("text-caption text-grey q-mb-xs")
+
+        async def _handle_upload(e) -> None:  # noqa: ANN001
+            import json
+
+            from pypproxy.exporter.importer import import_har, import_json
+
+            try:
+                data = e.content.read()
+                # Auto-detect format
+                parsed = json.loads(data)
+                if "log" in parsed and "entries" in parsed.get("log", {}):
+                    count = import_har(data, store)
+                    ui.notify(f"Imported {count} entries from HAR", type="positive")
+                else:
+                    count = import_json(data, store)
+                    ui.notify(f"Imported {count} entries from JSON", type="positive")
+            except Exception as err:
+                ui.notify(f"Import failed: {err}", type="negative")
+
+        ui.upload(
+            label="Drop HAR/JSON here",
+            on_upload=_handle_upload,
+            auto_upload=True,
+        ).props("accept=.har,.json flat").classes("w-full q-mb-md")
+
+        ui.separator()
+
+        # --- Paste JSON ---
+        ui.label("Or paste HAR/JSON directly:").classes("text-caption text-grey q-mb-xs")
+        paste_area = (
+            ui.textarea(placeholder='{"log": {"entries": [...]}} or [{"method": "GET", ...}]')
+            .props("outlined dense rows=10")
+            .classes("w-full font-mono text-xs")
+        )
+
+        async def _import_paste() -> None:
+            import json
+
+            from pypproxy.exporter.importer import import_har, import_json
+
+            text = paste_area.value.strip()
+            if not text:
+                ui.notify("Nothing to import", type="warning")
+                return
+            try:
+                parsed = json.loads(text)
+                if "log" in parsed and "entries" in parsed.get("log", {}):
+                    count = import_har(text, store)
+                    ui.notify(f"Imported {count} entries from HAR", type="positive")
+                else:
+                    count = import_json(text, store)
+                    ui.notify(f"Imported {count} entries from JSON", type="positive")
+                paste_area.value = ""
+            except Exception as err:
+                ui.notify(f"Import failed: {err}", type="negative")
+
+        ui.button("Import", icon="upload", on_click=_import_paste).props("color=primary q-mt-sm")
+
+        ui.separator().classes("q-my-md")
+
+        # --- Full-text search ---
+        ui.label("Full-text search").classes("text-subtitle2 q-mb-sm")
+        ui.label("Search across all captured request/response bodies, headers, and URLs.").classes(
+            "text-caption text-grey q-mb-xs"
+        )
+
+        with ui.row().classes("gap-2 items-center w-full"):
+            search_input = (
+                ui.input(placeholder="Search term…").props("dense outlined dark").classes("flex-1")
+            )
+            search_btn = ui.button("Search", icon="search").props("color=primary size=sm")
+
+        search_label = ui.label("").classes("text-caption text-grey q-mt-xs")
+        search_table = (
+            ui.table(
+                columns=[
+                    {
+                        "name": "id",
+                        "label": "ID",
+                        "field": "entry_id",
+                        "align": "right",
+                        "style": "width:60px",
+                    },
+                    {"name": "snippet", "label": "Match", "field": "snippet", "align": "left"},
+                    {
+                        "name": "rank",
+                        "label": "Score",
+                        "field": "rank",
+                        "align": "right",
+                        "style": "width:80px",
+                    },
+                ],
+                rows=[],
+                row_key="entry_id",
+            )
+            .classes("w-full")
+            .props("dense flat dark")
+        )
+
+        async def _search() -> None:
+            q = search_input.value.strip()
+            if not q:
+                return
+            db = getattr(store, "_db", None)
+            if db is None:
+                # fallback to in-memory
+                from pypproxy.store.models import Filter
+
+                entries, total = store.list(Filter(search=q), 0, 50)
+                rows = [
+                    {"entry_id": e.id, "rank": 0.0, "snippet": f"{e.host}{e.path}"} for e in entries
+                ]
+                search_label.text = f"{total} results (in-memory search)"
+            else:
+                results = await db.search(q, limit=50)
+                rows = [r.to_dict() for r in results]
+                search_label.text = f"{len(rows)} results"
+            search_table.rows = rows
+            search_table.update()
+
+        search_btn.on("click", _search)
+        search_input.on("keydown.enter", _search)

pypproxy/ui/intercept_dialog.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import asyncio
+
+from nicegui import ui
+
+from pypproxy.intercept.manager import InterceptManager, PendingRequest
+
+
+def build_intercept_panel(mgr: InterceptManager, container: ui.element) -> None:
+    """Render the intercept panel inside container. Polls for pending requests."""
+
+    async def _poller() -> None:
+        q = mgr.subscribe()
+        try:
+            while True:
+                try:
+                    req: PendingRequest = q.get_nowait()
+                    _show_dialog(req, mgr)
+                except asyncio.QueueEmpty:
+                    pass
+                await asyncio.sleep(0.1)
+        except asyncio.CancelledError:
+            mgr.unsubscribe(q)
+
+    asyncio.ensure_future(_poller())
+
+
+def _show_dialog(req: PendingRequest, mgr: InterceptManager) -> None:
+    with ui.dialog() as dlg, ui.card().classes("w-full").style("min-width:700px"):
+        ui.label(f"Intercepted: {req.method} {req.scheme}://{req.host}{req.path}").classes(
+            "text-subtitle1 text-weight-bold"
+        )
+
+        # Headers editor
+        ui.label("Headers").classes("text-caption text-weight-bold q-mt-sm")
+        headers_text = "\n".join(f"{k}: {', '.join(v)}" for k, v in req.headers.items())
+        headers_input = (
+            ui.textarea(value=headers_text)
+            .props("outlined dense rows=8")
+            .classes("w-full font-mono text-xs")
+        )
+
+        # Body editor
+        ui.label("Body").classes("text-caption text-weight-bold q-mt-sm")
+        body_text = req.body.decode(errors="replace")
+        body_input = (
+            ui.textarea(value=body_text)
+            .props("outlined dense rows=6")
+            .classes("w-full font-mono text-xs")
+        )
+
+        def _forward() -> None:
+            # Parse edited headers back
+            edited_headers: dict[str, list[str]] = {}
+            for line in headers_input.value.splitlines():
+                if ":" in line:
+                    k, _, v = line.partition(":")
+                    edited_headers.setdefault(k.strip().lower(), []).append(v.strip())
+            edited_body = body_input.value.encode()
+            mgr.forward(req.id, edited_headers, edited_body)
+            dlg.close()
+            ui.notify("Forwarded", type="positive")
+
+        def _drop() -> None:
+            mgr.drop(req.id)
+            dlg.close()
+            ui.notify("Dropped", type="warning")
+
+        with ui.row().classes("q-mt-sm gap-2"):
+            ui.button("Forward", icon="send", on_click=_forward).props("color=positive size=sm")
+            ui.button("Drop", icon="block", on_click=_drop).props("color=negative size=sm")
+
+    dlg.open()

pypproxy/ui/resender.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import json
+
+import httpx
+from nicegui import ui
+
+from pypproxy.store.models import Entry
+from pypproxy.store.store import Store
+
+
+def build_resender_tab(store: Store) -> None:
+    """Render the Resender tab content."""
+    state: dict = {"tabs": [], "active": None}
+
+    with ui.column().classes("w-full h-full"):
+        # Tab bar
+        with ui.row().classes("items-center gap-2 q-pa-sm").style("border-bottom:1px solid #333"):
+            ui.label("Resender").classes("text-subtitle2")
+            ui.button("+ New", icon="add", on_click=lambda: _new_tab(state, tab_panels)).props(
+                "size=sm flat color=primary"
+            )
+
+        # Tab panels
+        with ui.element("div").classes("w-full flex-1 overflow-auto") as tab_panels:
+            ui.label("Click '+ New' or drag an entry here to create a resender tab.").classes(
+                "text-grey q-pa-md"
+            )
+
+    # expose method to open entry
+    tab_panels._open_entry = lambda e: _open_entry(e, state, tab_panels)  # type: ignore[attr-defined]
+
+
+def open_entry_in_resender(entry: Entry, panel: ui.element) -> None:
+    fn = getattr(panel, "_open_entry", None)
+    if fn:
+        fn(entry)
+
+
+def _new_tab(state: dict, container: ui.element, entry: Entry | None = None) -> None:
+    tab_id = len(state["tabs"])
+    tab_state: dict = {
+        "id": tab_id,
+        "method": entry.method if entry else "GET",
+        "url": f"{entry.scheme}://{entry.host}{entry.path}" if entry else "https://",
+        "headers": "\n".join(f"{k}: {', '.join(v)}" for k, v in (entry.req_headers or {}).items())
+        if entry
+        else "",
+        "body": entry.req_body.decode(errors="replace") if (entry and entry.req_body) else "",
+        "result": "",
+    }
+    state["tabs"].append(tab_state)
+    state["active"] = tab_id
+    container.clear()
+    _render_tabs(state, container)
+
+
+def _open_entry(entry: Entry, state: dict, container: ui.element) -> None:
+    _new_tab(state, container, entry)
+
+
+def _render_tabs(state: dict, container: ui.element) -> None:
+    container.clear()
+    with container:
+        for tab in state["tabs"]:
+            _render_tab(tab, state, container)
+
+
+def _render_tab(tab: dict, state: dict, container: ui.element) -> None:
+    with ui.card().classes("w-full q-mb-sm"):
+        # Method + URL row
+        with ui.row().classes("items-center gap-2 w-full"):
+            method_input = (
+                ui.select(
+                    ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+                    value=tab["method"],
+                )
+                .props("dense outlined dark")
+                .classes("w-28")
+            )
+            url_input = ui.input(value=tab["url"]).props("dense outlined dark").classes("flex-1")
+            send_btn = ui.button("Send", icon="send").props("color=primary size=sm")
+
+        # Headers
+        ui.label("Headers").classes("text-caption text-weight-bold q-mt-xs")
+        headers_input = (
+            ui.textarea(value=tab["headers"])
+            .props("outlined dense rows=4")
+            .classes("w-full font-mono text-xs")
+        )
+
+        # Body
+        ui.label("Body").classes("text-caption text-weight-bold")
+        body_input = (
+            ui.textarea(value=tab["body"])
+            .props("outlined dense rows=5")
+            .classes("w-full font-mono text-xs")
+        )
+
+        # Result
+        ui.label("Response").classes("text-caption text-weight-bold")
+        result_area = (
+            ui.textarea(value=tab["result"])
+            .props("outlined dense rows=8 readonly")
+            .classes("w-full font-mono text-xs")
+        )
+
+        async def _send() -> None:
+            method = method_input.value
+            url = url_input.value
+            headers: dict[str, str] = {}
+            for line in headers_input.value.splitlines():
+                if ":" in line:
+                    k, _, v = line.partition(":")
+                    headers[k.strip()] = v.strip()
+            body = body_input.value.encode()
+            try:
+                async with httpx.AsyncClient(verify=False, timeout=30, http2=True) as client:
+                    resp = await client.request(
+                        method=method, url=url, headers=headers, content=body
+                    )
+                ct = resp.headers.get("content-type", "")
+                try:
+                    if "json" in ct:
+                        body_text = json.dumps(resp.json(), indent=2, ensure_ascii=False)
+                    else:
+                        body_text = resp.text
+                except Exception:
+                    body_text = resp.text
+                result_area.value = (
+                    f"HTTP {resp.status_code} ({resp.elapsed.total_seconds() * 1000:.0f}ms)\n"
+                    + "\n".join(f"{k}: {v}" for k, v in resp.headers.items())
+                    + f"\n\n{body_text}"
+                )
+                ui.notify(f"{resp.status_code}", type="positive")
+            except Exception as e:
+                result_area.value = f"Error: {e}"
+                ui.notify(str(e), type="negative")
+
+        send_btn.on("click", _send)