pypproxy 0.1.0__py3-none-any.whl

pypproxy/ui/settings.py

@@ -0,0 +1,413 @@
+from __future__ import annotations
+
+from nicegui import ui
+
+from pypproxy.cert.client_cert import ClientCert, ClientCertManager
+from pypproxy.config.config import Config
+from pypproxy.dns.server import DNSServer
+from pypproxy.rule.rule import RuleManager
+
+
+def build_settings_page(
+    cfg: Config,
+    rules: RuleManager,
+    cert_mgr: ClientCertManager,
+    dns_server: DNSServer | None = None,
+    scope_mgr=None,
+) -> None:
+    @ui.page("/settings")
+    async def settings() -> None:
+        ui.dark_mode().enable()
+
+        with ui.header().classes("items-center q-px-md gap-4").style("background:#1a1a2e"):
+            ui.button(icon="arrow_back", on_click=lambda: ui.navigate.to("/")).props("flat dark")
+            ui.label("Settings").classes("text-h6 text-weight-bold")
+
+        with ui.tabs().props("dense dark").classes("bg-dark") as tabs:
+            rules_tab = ui.tab("Rules", icon="rule")
+            scope_tab = ui.tab("Scope", icon="target")
+            passthrough_tab = ui.tab("SSL Passthrough", icon="lock_open")
+            dns_tab = ui.tab("DNS Overwrite", icon="dns")
+            ports_tab = ui.tab("Listen Ports", icon="router")
+            certs_tab = ui.tab("Client Certs", icon="badge")
+
+        with (
+            ui.tab_panels(tabs, value=rules_tab)
+            .classes("w-full")
+            .style("height:calc(100vh - 96px)")
+        ):
+            # --- Rules tab ---
+            with ui.tab_panel(rules_tab).classes("q-pa-md"):
+                _build_rules_panel(rules)
+
+            # --- Scope tab ---
+            with ui.tab_panel(scope_tab).classes("q-pa-md"):
+                _build_scope_panel(scope_mgr)
+
+            # --- SSL Passthrough tab ---
+            with ui.tab_panel(passthrough_tab).classes("q-pa-md"):
+                _build_passthrough_panel(cfg)
+
+            # --- DNS Overwrite tab ---
+            with ui.tab_panel(dns_tab).classes("q-pa-md"):
+                _build_dns_panel(cfg, dns_server)
+
+            # --- Listen Ports tab ---
+            with ui.tab_panel(ports_tab).classes("q-pa-md"):
+                _build_ports_panel(cfg)
+
+            # --- Client Certs tab ---
+            with ui.tab_panel(certs_tab).classes("q-pa-md"):
+                _build_certs_panel(cert_mgr)
+
+
+def _build_scope_panel(scope_mgr) -> None:  # noqa: ANN001
+    from pypproxy.store.scope import ScopeRule
+
+    ui.label("Scope").classes("text-subtitle1 q-mb-sm")
+    ui.label(
+        "When enabled, only in-scope hosts are captured. All others are proxied without recording."
+    ).classes("text-caption text-grey q-mb-md")
+
+    if scope_mgr is None:
+        ui.label("Scope manager not initialized.").classes("text-grey")
+        return
+
+    enabled_toggle = ui.switch("Enable scope filtering", value=scope_mgr.enabled).props(
+        "dense dark color=primary"
+    )
+    enabled_toggle.on("update:model-value", lambda e: scope_mgr.set_enabled(e.args))
+
+    ui.separator().classes("q-my-md")
+    container = ui.column().classes("w-full")
+
+    def _refresh() -> None:
+        container.clear()
+        with container:
+            for rule in scope_mgr.list():
+                with ui.row().classes("items-center gap-2"):
+                    ui.badge(rule.mode, color="grey-7")
+                    ui.label(rule.pattern).classes("flex-1 font-mono")
+                    ui.button(
+                        icon="remove",
+                        on_click=lambda p=rule.pattern: (scope_mgr.remove(p), _refresh()),
+                    ).props("flat dense color=negative size=sm")
+
+    _refresh()
+
+    with ui.row().classes("gap-2 items-center q-mt-sm"):
+        pattern_input = (
+            ui.input(label="Pattern (e.g. *.example.com)")
+            .props("dense outlined dark")
+            .classes("w-64")
+        )
+        mode_select = (
+            ui.select(["glob", "regex"], value="glob", label="Mode")
+            .props("dense outlined dark")
+            .classes("w-24")
+        )
+
+        def _add() -> None:
+            p = pattern_input.value.strip()
+            if p:
+                scope_mgr.add(ScopeRule(pattern=p, mode=mode_select.value))
+                pattern_input.value = ""
+                _refresh()
+
+        ui.button("Add", icon="add", on_click=_add).props("color=primary size=sm")
+
+
+def _build_rules_panel(rules: RuleManager) -> None:
+    ui.label("Intercept Rules").classes("text-subtitle1 q-mb-sm")
+    ui.label("Rules are evaluated in priority order. Higher number = higher priority.").classes(
+        "text-caption text-grey q-mb-md"
+    )
+
+    rules_container = ui.column().classes("w-full")
+
+    def _refresh() -> None:
+        rules_container.clear()
+        with rules_container:
+            for rule in rules.list():
+                with (
+                    ui.card().classes("w-full q-mb-xs"),
+                    ui.row().classes("items-center gap-2 w-full"),
+                ):
+                    ui.switch(value=rule.enabled).on(
+                        "update:model-value",
+                        lambda v, r=rule: (setattr(r, "enabled", v.args), rules.update(r)),
+                    )
+                    ui.label(rule.name).classes("text-weight-medium flex-1")
+                    ui.badge(
+                        rule.action.value,
+                        color={
+                            "block": "negative",
+                            "modify": "warning",
+                            "redirect": "info",
+                            "passthrough": "positive",
+                        }.get(rule.action.value, "grey"),
+                    )
+                    ui.label(f"p={rule.priority}").classes("text-caption text-grey")
+                    ui.button(
+                        icon="delete",
+                        on_click=lambda r=rule: (rules.delete(r.id), _refresh()),
+                    ).props("flat dense color=negative size=sm")
+
+    _refresh()
+
+    ui.separator().classes("q-my-md")
+    ui.label("Add Rule").classes("text-subtitle2")
+    with ui.row().classes("gap-2 items-end q-mt-sm"):
+        name_input = ui.input(label="Name").props("dense outlined dark").classes("w-48")
+        action_select = (
+            ui.select(
+                ["block", "passthrough", "modify", "redirect"],
+                value="block",
+                label="Action",
+            )
+            .props("dense outlined dark")
+            .classes("w-32")
+        )
+        priority_input = (
+            ui.number(label="Priority", value=0).props("dense outlined dark").classes("w-24")
+        )
+        field_select = (
+            ui.select(
+                ["host", "path", "method", "header", "body"],
+                value="host",
+                label="Field",
+            )
+            .props("dense outlined dark")
+            .classes("w-24")
+        )
+        op_select = (
+            ui.select(
+                ["contains", "equals", "prefix", "regex"],
+                value="contains",
+                label="Op",
+            )
+            .props("dense outlined dark")
+            .classes("w-28")
+        )
+        value_input = ui.input(label="Value").props("dense outlined dark").classes("w-48")
+
+        def _add() -> None:
+            from pypproxy.rule.rule import Condition, MatchField, Rule
+
+            if not name_input.value or not value_input.value:
+                ui.notify("Name and Value are required", type="warning")
+                return
+            rule = Rule(
+                name=name_input.value,
+                enabled=True,
+                priority=int(priority_input.value or 0),
+                action=action_select.value,
+                conditions=[
+                    Condition(
+                        field=MatchField(field_select.value),
+                        op=op_select.value,
+                        value=value_input.value,
+                    )
+                ],
+            )
+            rules.add(rule)
+            name_input.value = ""
+            value_input.value = ""
+            _refresh()
+            ui.notify(f"Rule '{rule.name}' added", type="positive")
+
+        ui.button("Add", icon="add", on_click=_add).props("color=primary size=sm")
+
+
+def _build_passthrough_panel(cfg: Config) -> None:
+    ui.label("SSL Passthrough").classes("text-subtitle1 q-mb-sm")
+    ui.label(
+        "Hosts listed here will be tunneled without TLS interception (for certificate pinning, etc.)."
+    ).classes("text-caption text-grey q-mb-md")
+
+    container = ui.column().classes("w-full")
+
+    def _refresh() -> None:
+        container.clear()
+        with container:
+            for host in cfg.proxy.ignore:
+                with ui.row().classes("items-center gap-2"):
+                    ui.label(host).classes("flex-1 font-mono")
+                    ui.button(
+                        icon="remove",
+                        on_click=lambda h=host: (cfg.proxy.ignore.remove(h), _refresh()),
+                    ).props("flat dense color=negative size=sm")
+
+    _refresh()
+
+    with ui.row().classes("gap-2 items-center q-mt-sm"):
+        host_input = ui.input(label="Host").props("dense outlined dark").classes("w-64")
+
+        def _add() -> None:
+            h = host_input.value.strip()
+            if h and h not in cfg.proxy.ignore:
+                cfg.proxy.ignore.append(h)
+                host_input.value = ""
+                _refresh()
+
+        ui.button("Add", icon="add", on_click=_add).props("color=primary size=sm")
+
+
+def _build_dns_panel(cfg: Config, dns_server: DNSServer | None) -> None:
+    ui.label("DNS Overwrite").classes("text-subtitle1 q-mb-sm")
+    ui.label(
+        "Redirect specific domains to a target IP. Start the DNS server and point devices to this machine."
+    ).classes("text-caption text-grey q-mb-md")
+
+    overrides: dict[str, str] = {}
+    container = ui.column().classes("w-full")
+
+    with ui.row().classes("items-center gap-2 q-mb-md"):
+        dns_status = ui.badge("Stopped", color="grey")
+        if dns_server:
+            ui.button(
+                "Start DNS",
+                icon="play_arrow",
+                on_click=lambda: _start_dns(dns_server, dns_status, overrides),
+            ).props("size=sm color=positive")
+        ui.label("Port 53153 (use iptables/pfctl to redirect port 53)").classes(
+            "text-caption text-grey"
+        )
+
+    def _refresh() -> None:
+        container.clear()
+        with container:
+            for domain, ip in overrides.items():
+                with ui.row().classes("items-center gap-2"):
+                    ui.label(domain).classes("flex-1 font-mono")
+                    ui.label("→").classes("text-grey")
+                    ui.label(ip).classes("font-mono text-positive")
+                    ui.button(
+                        icon="remove",
+                        on_click=lambda d=domain: (
+                            overrides.pop(d, None),
+                            _refresh_dns(dns_server, overrides),
+                            _refresh(),
+                        ),
+                    ).props("flat dense color=negative size=sm")
+
+    _refresh()
+
+    with ui.row().classes("gap-2 items-center q-mt-sm"):
+        domain_input = ui.input(label="Domain").props("dense outlined dark").classes("w-48")
+        ip_input = ui.input(label="Target IP").props("dense outlined dark").classes("w-36")
+
+        def _add() -> None:
+            d, ip = domain_input.value.strip(), ip_input.value.strip()
+            if d and ip:
+                overrides[d] = ip
+                domain_input.value = ""
+                ip_input.value = ""
+                _refresh_dns(dns_server, overrides)
+                _refresh()
+
+        ui.button("Add", icon="add", on_click=_add).props("color=primary size=sm")
+
+
+async def _start_dns(server: DNSServer, badge: ui.badge, overrides: dict) -> None:
+    try:
+        server.set_overrides(overrides)
+        await server.start()
+        badge.text = "Running"
+        badge.props("color=positive")
+        ui.notify("DNS server started on :53153", type="positive")
+    except Exception as e:
+        ui.notify(f"Failed to start DNS: {e}", type="negative")
+
+
+def _refresh_dns(server: DNSServer | None, overrides: dict) -> None:
+    if server:
+        server.set_overrides(overrides)
+
+
+def _build_ports_panel(cfg: Config) -> None:
+    ui.label("Listen Ports").classes("text-subtitle1 q-mb-sm")
+    ui.label("Configure proxy listen address and port.").classes("text-caption text-grey q-mb-md")
+
+    with ui.row().classes("gap-4 items-end"):
+        addr_input = (
+            ui.input(label="Proxy Address", value=cfg.proxy.addr)
+            .props("dense outlined dark")
+            .classes("w-48")
+        )
+        port_input = (
+            ui.number(label="Proxy Port", value=cfg.proxy.port)
+            .props("dense outlined dark")
+            .classes("w-28")
+        )
+        ui_port_input = (
+            ui.number(label="UI Port", value=cfg.ui.port)
+            .props("dense outlined dark")
+            .classes("w-28")
+        )
+
+        def _save() -> None:
+            cfg.proxy.addr = addr_input.value
+            cfg.proxy.port = int(port_input.value or 8080)
+            cfg.ui.port = int(ui_port_input.value or 8081)
+            ui.notify("Port settings saved (takes effect on restart)", type="info")
+
+        ui.button("Save", icon="save", on_click=_save).props("color=primary size=sm")
+
+    ui.label("Note: Port changes take effect after restarting paxy.").classes(
+        "text-caption text-grey q-mt-sm"
+    )
+
+
+def _build_certs_panel(cert_mgr: ClientCertManager) -> None:
+    ui.label("Client Certificates").classes("text-subtitle1 q-mb-sm")
+    ui.label("Client certificates are sent to matching hosts during TLS handshake.").classes(
+        "text-caption text-grey q-mb-md"
+    )
+
+    container = ui.column().classes("w-full")
+
+    def _refresh() -> None:
+        container.clear()
+        with container:
+            for cert in cert_mgr.list():
+                with ui.card().classes("w-full q-mb-xs"), ui.row().classes("items-center gap-2"):
+                    ui.icon("badge").classes("text-primary")
+                    with ui.column().classes("flex-1"):
+                        ui.label(cert.name).classes("text-weight-medium")
+                        ui.label(f"{cert.host_pattern}  •  {cert.cert_path}").classes(
+                            "text-caption text-grey"
+                        )
+                    ui.button(
+                        icon="delete",
+                        on_click=lambda n=cert.name: (cert_mgr.remove(n), _refresh()),
+                    ).props("flat dense color=negative size=sm")
+
+    _refresh()
+
+    ui.separator().classes("q-my-md")
+    ui.label("Add Client Certificate").classes("text-subtitle2")
+    with ui.grid(columns=2).classes("gap-2 q-mt-sm"):
+        name_input = ui.input(label="Name").props("dense outlined dark")
+        pattern_input = ui.input(label="Host Pattern", value="*").props("dense outlined dark")
+        cert_input = ui.input(label="Certificate Path (.pem)").props("dense outlined dark")
+        key_input = ui.input(label="Key Path (.pem)").props("dense outlined dark")
+
+    def _add() -> None:
+        if not name_input.value or not cert_input.value or not key_input.value:
+            ui.notify("All fields are required", type="warning")
+            return
+        cert_mgr.add(
+            ClientCert(
+                name=name_input.value,
+                cert_path=cert_input.value,
+                key_path=key_input.value,
+                host_pattern=pattern_input.value or "*",
+            )
+        )
+        for inp in (name_input, cert_input, key_input):
+            inp.value = ""
+        _refresh()
+        ui.notify("Certificate added", type="positive")
+
+    ui.button("Add", icon="add", on_click=_add).props("color=primary size=sm q-mt-sm")

pypproxy/ui/theme.py

@@ -0,0 +1,59 @@
+from nicegui import ui
+
+METHOD_COLORS: dict[str, str] = {
+    "GET": "blue",
+    "POST": "green",
+    "PUT": "orange",
+    "PATCH": "purple",
+    "DELETE": "red",
+    "HEAD": "grey",
+    "OPTIONS": "grey",
+}
+
+STATUS_COLORS: dict[int, str] = {}
+
+
+def status_color(code: int) -> str:
+    if 200 <= code < 300:
+        return "positive"
+    if 300 <= code < 400:
+        return "info"
+    if 400 <= code < 500:
+        return "warning"
+    if code >= 500:
+        return "negative"
+    return "grey"
+
+
+def method_badge(method: str) -> None:
+    color = METHOD_COLORS.get(method.upper(), "grey")
+    ui.badge(method, color=color).props("rounded")
+
+
+def status_badge(code: int) -> None:
+    if code == 0:
+        return
+    ui.badge(str(code), color=status_color(code)).props("rounded")
+
+
+def apply_dark_theme() -> None:
+    ui.add_head_html("""
+    <style>
+      .paxy-row-modified { background: rgba(255, 200, 0, 0.08) !important; }
+      .paxy-row-blocked  { background: rgba(255, 50,  50, 0.08) !important; }
+      .paxy-row-selected { background: rgba(100, 150, 255, 0.15) !important; }
+      .paxy-body-pre {
+        font-family: monospace;
+        font-size: 12px;
+        white-space: pre-wrap;
+        word-break: break-all;
+        max-height: 400px;
+        overflow-y: auto;
+        background: rgba(0,0,0,0.2);
+        padding: 8px;
+        border-radius: 4px;
+      }
+      .paxy-header-table td { padding: 2px 8px; font-size: 12px; }
+      .paxy-header-table td:first-child { color: #aaa; min-width: 160px; }
+    </style>
+    """)

pypproxy-0.1.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: pypproxy
+Version: 0.1.0
+Summary: MITM HTTP/HTTPS proxy for inspecting and modifying traffic
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Dist: brotli>=1.1.0
+Requires-Dist: cbor2>=5.6.0
+Requires-Dist: cryptography>=48.0.0
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: httpx[http2]>=0.27.0
+Requires-Dist: msgpack>=1.1.0
+Requires-Dist: nicegui>=3.12.1
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=15.0.0
+Requires-Dist: uvicorn[standard]>=0.30.0
+Requires-Dist: websockets>=16.0

pypproxy-0.1.0.dist-info/RECORD

@@ -0,0 +1,72 @@
+pypproxy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/codec.py,sha256=VTwo3WutemcU3v5qjY_zCIS17P_vtqwXde3QcXfiKY0,5617
+pypproxy/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/api/server.py,sha256=sRYu98BslZqFPLvw1fm6xW4GVMppivewFbS8_kWJxgA,12125
+pypproxy/bulk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/bulk/sender.py,sha256=t905m7vIliqKMckiKFLE4mC3JUxm7veQEcBJVTj4Fmg,2752
+pypproxy/cert/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/cert/ca.py,sha256=O0C-Er_WCrQXemd-Km1xfPFcrlSsjRxydNgstFX-PfE,5314
+pypproxy/cert/client_cert.py,sha256=zNMEXLL_OuoonFeG8MpJOAaoAfgMTrA3gVD6Jf7gjF4,1726
+pypproxy/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/config/config.py,sha256=bfH7V-SZDtKzBtdzP3f7ST2LT6cq1Xv8p0fkvKvaqSc,2862
+pypproxy/dns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/dns/server.py,sha256=I1R084TjS-DuC01NIcPkXoEIkJglRKGivKeH3m5XeOk,4973
+pypproxy/exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/exporter/exporter.py,sha256=96ZhTkk93HUxMFrwUfwrc8FyRVja2dNtRTDAJD2bZT4,3810
+pypproxy/exporter/importer.py,sha256=oWFwRmA-4aUy4zeZbWanwbbNE1ICgxBmVHuu757N2ao,4991
+pypproxy/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/graphql/detector.py,sha256=jJgSLoHP1wOtRkVW4d0flsCsXZfp0Hv_tCjj7VZ49oc,2575
+pypproxy/graphql/introspection.py,sha256=HpbEW4_a_n0FX-6EeDsiZfuJ6TXel22NjSn3TyQlAxc,5683
+pypproxy/graphql/modifier.py,sha256=qzJ5fNavNKtI2102ZcLDpZQtT_WpcgROgIeh-cHwNiI,3093
+pypproxy/graphql/schema_store.py,sha256=BQWf1sveEvUnk489yjFPt8LCL701W1CP-T2TdG68ER8,856
+pypproxy/intercept/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/intercept/manager.py,sha256=_dBiqMotuvfN-7UMiP7vN2hCdteXQkcK9TJ9_VcH6As,4066
+pypproxy/interceptor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/interceptor/interceptor.py,sha256=rSA_B2jKACPbAQCk_G7UUX1J8BcW-GR815rQHcv7cFQ,5108
+pypproxy/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/proto/grpc.py,sha256=gZdkGA9LlnQMPs4lk-uzEouQgiCPFxfei3aMIYFRlKM,1278
+pypproxy/proto/mqtt.py,sha256=7PUkcvEMiW56bwyOKCHNbnSNiLf_Ts6uq6ylWCk8kVo,2913
+pypproxy/proto/ws.py,sha256=5SdhChNLC-KHUzJPXLem8vqm9DvDg2xRIden1N_AzEU,3230
+pypproxy/proto/ws_intercept.py,sha256=2d_R_fYfAeaeP0JJq3YnkSKTH_zIWvJEN8UtogM-VPY,3388
+pypproxy/proxy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/proxy/proxy.py,sha256=3oeEdJEipDTQ20nAu-Ka_RCCaZ3JRxjBOVnuZD38v1A,13118
+pypproxy/replay/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/replay/replay.py,sha256=y3Yo9QVbufaT4VskKyxeWG59bZHwrg5RLa6jVOIRgK0,2100
+pypproxy/rule/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/rule/rule.py,sha256=V7EJir77KhpSzmWViaReF6ttsxm6YiGtlBQzL2jx2TM,5763
+pypproxy/scan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/scan/scanner.py,sha256=OinfUDJQUfpf4IYm2VtScrtbbj60yoSAgnCLtUUeQ4E,8433
+pypproxy/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/script/engine.py,sha256=YjN63iFqrguFuLlS7B1f0eUOcHfWS7bcCiGvGakBjqs,1607
+pypproxy/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/security/header_checker.py,sha256=MUBH0J3R88fHr9JPcnpSLi6PdoBgySnjfzfjks7mCVg,8757
+pypproxy/security/int_overflow.py,sha256=ZaaIqYwvSfrm02C6HweMLQ3s9n95Laeh0AieiWPCt0o,6321
+pypproxy/security/jwt_checker.py,sha256=02Y3gLfBWfyVo8H-9vAbEoy07ZAu4JM9uJbdsOeJ1Qc,8606
+pypproxy/security/plugin.py,sha256=65v6xLv9SBnuAapwrxDNH-V3DNH2KH9waqFEN4ZgMu4,4953
+pypproxy/security/randomness.py,sha256=7T8X9JA3jZ58kMWcAW2oJV8_7d70IAQhGPzhpTwc9-c,4805
+pypproxy/store/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/store/db.py,sha256=FhCZPH9g-G-3zSTaGoA60jYtp_ebAccnXejv3o3GPo0,6070
+pypproxy/store/filter_parser.py,sha256=i0kHfAEUh4Ij0qiXHMYiguQavc80I6-I1oKq1Ylhoo0,5089
+pypproxy/store/fts.py,sha256=98ZJgsro0WGDLtqdhx_HKWSv9TnUd9uZ2hp3RJeBONw,3142
+pypproxy/store/models.py,sha256=HdeONRuosHt6YmzlGh6lLCYyvvC5jYPYdTF8jb8jNxQ,2633
+pypproxy/store/scope.py,sha256=NOO1Nf4t8d3F8m6ZJLfhinlcvpHhUsh8hLS1-CBZEN0,1685
+pypproxy/store/store.py,sha256=yk69W9ezw4JqK0s8MPHtjYAF9cRrf3Ypd41ruUtS9z0,3743
+pypproxy/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypproxy/ui/app.py,sha256=khCpYrxk4-xuYIQj16XKcmD-aWlTGY2S4DqsSDIRkRc,14514
+pypproxy/ui/bulk_sender_ui.py,sha256=LI9bwS_tTxMwUCfKpa0IgNypn7IWsGrphW4AmYLfBW4,4809
+pypproxy/ui/cui.py,sha256=84oVg5s2ca1XEo_MyNmwU042wQpxLSr0Ra4AvGbzYwc,4674
+pypproxy/ui/detail.py,sha256=B0pIf5Ep_cEtEdUdLf5t6m0S-hi51KvjhCno13foig0,6275
+pypproxy/ui/diff_view.py,sha256=ewN9UmGGpxJf-8OtgFZ7YsRXWa__mEhI7pNWVUWgV4E,3823
+pypproxy/ui/graphql_tab.py,sha256=Yw-0Bxzsrviu2PPZH00obbYKHv3ONrHvXj609gCKiIY,10658
+pypproxy/ui/import_tab.py,sha256=RbzVEKyN2oG4hvcIqH63nBuurdLnF4T5L7Fsxa4jtlU,5226
+pypproxy/ui/intercept_dialog.py,sha256=aSca1vX6R2DB6Krs7HnJ6hVQvic-cBJsoYitW1z1zDI,2666
+pypproxy/ui/resender.py,sha256=obiFQ_dKZN6RFpNh82oLSna7YRVmS2xlFqBJP4R7Vyg,5182
+pypproxy/ui/scan_tab.py,sha256=_OPjOLC6Gkz1oNFlqzcUdUjKsuLiBMjykzSeDozmF5E,3823
+pypproxy/ui/security_tab.py,sha256=jl05lGgZtwv1sYuoRQMxlI64jB4PmYUwAE78tcJtL3Q,16292
+pypproxy/ui/settings.py,sha256=W0Fl8xKdEi6ow5GRP9tYF7N5Nor-LMgRMfSTtDKAF_M,15744
+pypproxy/ui/theme.py,sha256=Yda_pGxT-WgcGH1jWmW1fpm-NqjwHEBRBxOWVSflwLo,1541
+pypproxy-0.1.0.dist-info/METADATA,sha256=OXYPv3FNFqLZ0nOg6F5-p4WpXMWoWhAicf56zV7XqWQ,580
+pypproxy-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pypproxy-0.1.0.dist-info/entry_points.txt,sha256=qGPuutdrIlY_LGUMNLmcBseWjgnGuNRX0P8oqnK1Es8,39
+pypproxy-0.1.0.dist-info/licenses/LICENSE,sha256=hO5vafKkFOjcGnOjmv0SScAeG3c7jTDD7EFT_KOLiHA,1061
+pypproxy-0.1.0.dist-info/RECORD,,

pypproxy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

pypproxy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pypproxy = main:main

pypproxy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.