netshow 0.1.1__py3-none-any.whl

netshow/__init__.py

@@ -0,0 +1,3 @@
+"""NetShow - A real-time network connection monitor with friendly service names."""
+
+__version__ = "0.1.0"

netshow/app.py

@@ -0,0 +1,390 @@
+import os
+from datetime import datetime
+from typing import TypedDict
+
+import psutil
+from textual import events
+from textual.app import App, ComposeResult
+from textual.containers import (
+    Container,
+    Horizontal,
+    ScrollableContainer,
+    Vertical,
+)
+from textual.reactive import reactive
+from textual.screen import Screen
+from textual.timer import Timer
+from textual.widgets import (
+    Button,
+    DataTable,
+    Footer,
+    Header,
+    Static,
+)
+
+from .helpers import get_lsof_conns, get_psutil_conns
+from .styles import CSS
+
+# Constants
+REFRESH_INTERVAL = 3.0  # seconds
+CONNECTION_COLUMNS = ["pid", "friendly", "proc", "laddr", "raddr", "status"]
+
+
+class ConnectionData(TypedDict):
+    """Type definition for connection data."""
+
+    pid: str
+    friendly: str
+    proc: str
+    laddr: str
+    raddr: str
+    status: str
+
+
+class ConnectionDetailScreen(Screen):
+    """Screen for displaying detailed information about a selected connection."""
+
+    BINDINGS = [("escape", "app.pop_screen", "Back to connections")]
+
+    def __init__(self, connection_data: ConnectionData):
+        super().__init__()
+        self.connection_data = connection_data
+        self.process_info = self._get_process_info(connection_data["pid"])
+
+    def _get_status_icon(self, status: str) -> str:
+        """Get an appropriate icon for connection status."""
+        status_icons = {
+            "ESTABLISHED": "✅",
+            "LISTEN": "👂",
+            "TIME_WAIT": "⏳",
+            "CLOSE_WAIT": "⏸️",
+            "SYN_SENT": "📤",
+            "SYN_RECV": "📥",
+            "FIN_WAIT1": "🔄",
+            "FIN_WAIT2": "🔁",
+            "CLOSING": "🔚",
+            "LAST_ACK": "🏁",
+        }
+        return status_icons.get(status, "❓")
+
+    def _get_process_info(self, pid_str: str) -> dict:
+        """Get additional process information if PID is available."""
+        if pid_str == "-":
+            return {}
+
+        try:
+            pid = int(pid_str)
+            proc = psutil.Process(pid)
+            return {
+                "name": proc.name(),
+                "exe": proc.exe(),
+                "cmd": " ".join(proc.cmdline()),
+                "create_time": proc.create_time(),
+                "status": proc.status(),
+                "username": proc.username(),
+                "cwd": proc.cwd(),
+                "num_threads": proc.num_threads(),
+                "cpu_percent": proc.cpu_percent(interval=0.1),
+                "memory_percent": proc.memory_percent(),
+                "open_files": proc.open_files(),
+                "connections": proc.connections(),
+            }
+        except (psutil.NoSuchProcess, psutil.AccessDenied, ValueError):
+            return {}
+
+    def compose(self) -> ComposeResult:
+        """Compose the detail screen layout."""
+        yield Header(show_clock=True)
+
+        with ScrollableContainer():
+            yield Static(
+                f"🔗 Connection Details: {self.connection_data['friendly']}",
+                id="detail_title",
+            )
+
+            with Horizontal(id="main_content"):
+                with Container(id="connection_details"):
+                    yield Static("🌐 Connection Info", classes="detail_title")
+                    yield Static(
+                        f"🆔 PID: {self.connection_data['pid']}", classes="detail_item"
+                    )
+                    yield Static(
+                        f"⚙️ Process: {self.connection_data['proc']}",
+                        classes="detail_item",
+                    )
+                    yield Static(
+                        f"🏷️  Friendly Name: {self.connection_data['friendly']}",
+                        classes="detail_item",
+                    )
+                    yield Static(
+                        f"🏠 Local Address: {self.connection_data['laddr']}",
+                        classes="detail_item",
+                        markup=False,
+                    )
+                    yield Static(
+                        f"🌐 Remote Address: {self.connection_data['raddr']}",
+                        classes="detail_item",
+                        markup=False,
+                    )
+
+                    status = self.connection_data["status"]
+                    status_icon = self._get_status_icon(status)
+                    yield Static(
+                        f"{status_icon} Status: {status}",
+                        classes=f"detail_item status-{status}",
+                    )
+
+                # Show additional process info if available
+                if self.process_info:
+                    with Container(id="process_info"):
+                        yield Static("🔧 Process Details", classes="detail_title")
+                        yield Static(
+                            f"📁 Executable: {self.process_info.get('exe', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"💻 Command Line: {self.process_info.get('cmd', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"📊 Status: {self.process_info.get('status', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"👤 User: {self.process_info.get('username', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"📂 Working Directory: {self.process_info.get('cwd', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"🧵 Threads: {self.process_info.get('num_threads', 'N/A')}",
+                            classes="detail_item",
+                        )
+
+                        cpu_percent = self.process_info.get("cpu_percent", 0.0)
+                        cpu_icon = (
+                            "🔥"
+                            if cpu_percent > 50
+                            else "⚡" if cpu_percent > 10 else "💤"
+                        )
+                        yield Static(
+                            f"{cpu_icon} CPU Usage: {cpu_percent:.1f}%",
+                            classes="detail_item",
+                        )
+
+                        memory_percent = self.process_info.get("memory_percent", 0.0)
+                        memory_display = (
+                            f"{memory_percent:.2f}%"
+                            if isinstance(memory_percent, (int, float))
+                            else "N/A"
+                        )
+                        memory_icon = (
+                            "🚨"
+                            if memory_percent > 80
+                            else "⚠️" if memory_percent > 50 else "💾"
+                        )
+                        yield Static(
+                            f"{memory_icon} Memory Usage: {memory_display}",
+                            classes="detail_item",
+                        )
+
+                        # Network connections from this process
+                        connections = self.process_info.get("connections", [])
+                        if connections:
+                            conn_count = (
+                                len(connections) if isinstance(connections, list) else 0
+                            )
+                            yield Static(
+                                f"🌐 Active Connections: {conn_count}",
+                                classes="detail_item",
+                            )
+
+            with Container(id="button_container"):
+                yield Button("🔙 Back to Connections", id="back_button")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press events."""
+        if event.button.id == "back_button":
+            self.app.pop_screen()
+
+
+class NetshowApp(App):
+    """A modern real‑time network connection monitor with enhanced visuals.
+
+    Features:
+    • **Beautiful gradient UI** with glass morphism effects
+    • **Animated status indicators** and visual feedback
+    • **Enhanced typography** with semantic icons
+    • **Preserves scroll position** when the table refreshes
+    • **Process-aware monitoring** with detailed drill-down views
+    • **Responsive design** that adapts to terminal size
+    """
+
+    CSS = CSS
+
+    total_connections = reactive(0)
+    active_connections = reactive(0)
+    listening_connections = reactive(0)
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        with Vertical():
+            with Container(id="stats_container"):
+                yield Static("🔄 Initializing NetShow…", id="status_bar")
+            yield DataTable(id="connections_table")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#connections_table", DataTable)
+        table.add_columns(
+            "🆔 PID",
+            "🔖 Service",
+            "⚙️  Process",
+            "🏠 Local Address",
+            "🌐 Remote Address",
+            "📊 Status",
+        )
+
+        # Enable cursor to allow row selection
+        table.cursor_type = "row"
+        table.can_focus = True
+
+        # Refresh at regular intervals
+        self.timer: Timer = self.set_interval(
+            REFRESH_INTERVAL, self.refresh_connections
+        )
+        self.refresh_connections()
+
+    def refresh_connections(self) -> None:
+        table = self.query_one("#connections_table", DataTable)
+
+        # Capture current scroll offset & cursor row
+        row_offset, col_offset = getattr(table, "scroll_offset", (0, 0))
+        cursor_row = getattr(table, "cursor_row", 0)
+
+        table.clear()
+
+        status_bar = self.query_one("#status_bar", Static)
+        using_root = os.geteuid() == 0
+
+        try:
+            conns = get_psutil_conns() if using_root else get_lsof_conns()
+        except (psutil.AccessDenied, PermissionError):
+            conns = get_lsof_conns()
+            using_root = False
+
+        # Count connection types for stats
+        established = listening = 0
+        for c in conns:
+            status = c["status"]
+            if status == "ESTABLISHED":
+                established += 1
+            elif status == "LISTEN":
+                listening += 1
+
+            # Add status icon to status column
+            status_icon = self._get_status_icon(status)
+            table.add_row(
+                c["pid"],
+                c["friendly"],
+                c["proc"],
+                c["laddr"],
+                c["raddr"],
+                f"{status_icon} {status}",
+            )
+
+        # Update reactive stats
+        self.total_connections = len(conns)
+        self.active_connections = established
+        self.listening_connections = listening
+
+        # Restore scroll & cursor
+        if hasattr(table, "scroll_to"):
+            table.scroll_to(row_offset, col_offset)
+        if cursor_row < table.row_count and hasattr(table, "cursor_coordinate"):
+            table.cursor_coordinate = (cursor_row, 0)  # type: ignore
+
+        source = "🔑 psutil (root)" if using_root else "🔧 lsof"
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        status_bar.update(
+            f"📊 Total: {len(conns)} | ✅ Active: {established} | 👂 Listening: {listening} | "
+            f"{source} | 🕒 {timestamp}"
+        )
+
+    def _get_status_icon(self, status: str) -> str:
+        """Get an appropriate icon for connection status."""
+        status_icons = {
+            "ESTABLISHED": "✅",
+            "LISTEN": "👂",
+            "TIME_WAIT": "⏳",
+            "CLOSE_WAIT": "⏸️",
+            "SYN_SENT": "📤",
+            "SYN_RECV": "📥",
+            "FIN_WAIT1": "🔄",
+            "FIN_WAIT2": "🔁",
+            "CLOSING": "🔚",
+            "LAST_ACK": "🏁",
+        }
+        return status_icons.get(status, "❓")
+
+    def _get_selected_connection_data(self, row_data: tuple) -> ConnectionData:
+        """Convert row data tuple to ConnectionData dict."""
+        # Extract status without icon (remove first 2 characters: icon + space)
+        status_with_icon = row_data[5]
+        clean_status = (
+            status_with_icon[2:] if len(status_with_icon) > 2 else status_with_icon
+        )
+
+        return ConnectionData(
+            pid=row_data[0],
+            friendly=row_data[1],
+            proc=row_data[2],
+            laddr=row_data[3],
+            raddr=row_data[4],
+            status=clean_status,
+        )
+
+    async def on_key(self, event: events.Key) -> None:
+        if event.key == "q":
+            await self.action_quit()
+        elif event.key == "enter":
+            # When Enter is pressed on a highlighted row
+            table = self.query_one("#connections_table", DataTable)
+            if table.cursor_row is not None and table.cursor_row < table.row_count:
+                # Pause refreshing while viewing details
+                self.timer.pause()
+
+                # Get the row data at cursor position and use it directly
+                row_data = table.get_row_at(table.cursor_row)
+                selected_data = self._get_selected_connection_data(tuple(row_data))
+                await self.push_screen(ConnectionDetailScreen(selected_data))
+
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        """Handle row highlighting in the DataTable."""
+        # This event fires when cursor moves over rows
+        pass
+
+    async def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Handle row selection in the DataTable."""
+        # Pause refreshing while viewing details
+        self.timer.pause()
+
+        # Get the selected row's data
+        table = self.query_one("#connections_table", DataTable)
+        row_data = table.get_row(event.row_key)
+        selected_data = self._get_selected_connection_data(tuple(row_data))
+
+        # Push the detail screen
+        await self.push_screen(ConnectionDetailScreen(selected_data))
+
+    async def on_screen_resume(self) -> None:
+        """Called when this screen is resumed (after popping another screen)."""
+        # Resume refreshing when returning from detail view
+        self.timer.resume()
+        self.refresh_connections()
+
+
+if __name__ == "__main__":
+    NetshowApp().run()

netshow/cli.py

@@ -0,0 +1,17 @@
+"""CLI entry point for NetShow."""
+
+import sys
+
+from .app import NetshowApp
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    try:
+        NetshowApp().run()
+    except KeyboardInterrupt:
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

netshow/helpers.py

@@ -0,0 +1,127 @@
+"""Helper functions for gathering network connections."""
+
+import re
+import subprocess
+from functools import lru_cache
+from typing import Optional
+
+import psutil
+
+# Friendly-name helpers
+STATIC_MAP = {
+    "rapportd": "Handoff Sync Process",
+    "IPNExtension": "Tailscale",
+    "Code\x20H": "VSCode",
+    "Adobe\x20H": "Adobe",
+}
+
+DOCKER_RE = re.compile(r"com\.docker", re.I)
+PLEX_RE = re.compile(r"plex", re.I)
+
+
+@lru_cache(maxsize=1)
+def _docker_container_lookup() -> dict[str, str]:
+    """Look up Docker container IDs and names."""
+    try:
+        out = subprocess.check_output(
+            ["docker", "ps", "--format", "{{.ID}} {{.Names}}"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+    except Exception:
+        return {}
+    return dict(line.split(maxsplit=1) for line in out.splitlines())
+
+
+def get_friendly_name(proc_name: str, pid: int, cmdline: Optional[str]) -> str:
+    """Get a friendly name for a process."""
+    if proc_name in STATIC_MAP:
+        return STATIC_MAP[proc_name]
+    if PLEX_RE.match(proc_name):
+        return "Plex Media Server"
+    if DOCKER_RE.match(proc_name):
+        cnt = len(_docker_container_lookup())
+        return f"Docker Desktop ({cnt} containers)" if cnt else "Docker Desktop"
+    if cmdline:
+        for cid, cname in _docker_container_lookup().items():
+            if cid in cmdline:
+                return f"Docker: {cname}"
+    return proc_name
+
+
+# Connection gathering helpers
+def get_psutil_conns() -> list[dict[str, str]]:
+    """Get network connections using psutil."""
+    conns = []
+    for conn in psutil.net_connections(kind="tcp"):
+        pid = conn.pid if conn.pid else None
+        try:
+            proc = psutil.Process(pid) if pid else None
+            proc_name = proc.name() if proc else "-"
+            cmdline = " ".join(proc.cmdline()) if proc else ""
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            proc_name, cmdline = "-", ""
+        conns.append(
+            {
+                "pid": str(pid) if pid else "-",
+                "proc": proc_name,
+                "friendly": get_friendly_name(proc_name, pid or 0, cmdline),
+                "laddr": (
+                    f"[{conn.laddr.ip}]:{conn.laddr.port}"
+                    if conn.laddr and ":" in conn.laddr.ip
+                    else f"{conn.laddr.ip}:{conn.laddr.port}" if conn.laddr else ""
+                ),
+                "raddr": (
+                    f"[{conn.raddr.ip}]:{conn.raddr.port}"
+                    if conn.raddr and ":" in conn.raddr.ip
+                    else f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else ""
+                ),
+                "status": conn.status,
+            }
+        )
+    return conns
+
+
+def get_lsof_conns() -> list[dict[str, str]]:
+    """Get network connections using lsof."""
+    try:
+        output = subprocess.check_output(
+            ["lsof", "-nP", "-iTCP", "-sTCP:ESTABLISHED,LISTEN"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+    except FileNotFoundError:
+        return []
+
+    conns = []
+    pattern = re.compile(
+        r"^(?P<proc>\S+)\s+(?P<pid>\d+)\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+TCP\s+(?P<addr>.+)$"
+    )
+    for line in output.splitlines()[1:]:
+        m = pattern.match(line)
+        if not m:
+            continue
+        proc_name = m["proc"]
+        pid = int(m["pid"])
+        addr_field = m["addr"]
+        status = ""
+        if "(" in addr_field:
+            addr_field, status = addr_field.rsplit("(", 1)
+            status = status.rstrip(")")
+        laddr, raddr = (addr_field.split("->", 1) + [""])[:2]
+        laddr, raddr = laddr.strip(), raddr.strip()
+        try:
+            cmdline = " ".join(psutil.Process(pid).cmdline())
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            cmdline = ""
+        conns.append(
+            {
+                "pid": str(pid),
+                "proc": proc_name,
+                "friendly": get_friendly_name(proc_name, pid, cmdline),
+                "laddr": laddr,
+                "raddr": raddr,
+                "status": status,
+            }
+        )
+    return conns

netshow/styles.py

@@ -0,0 +1,234 @@
+"""Styles for the NetshowApp - Enhanced Selenized Dark Theme."""
+
+CSS = """
+/* === SELENIZED DARK COLOR PALETTE === */
+$bg_0: #103c48;
+$bg_1: #184956;
+$bg_2: #2d5b69;
+$dim_0: #72898f;
+$fg_0: #adbcbc;
+$fg_1: #cad8d9;
+
+$red: #fa5750;
+$green: #75b938;
+$yellow: #dbb32d;
+$blue: #4695f7;
+$magenta: #f275be;
+$cyan: #41c7b9;
+$orange: #ed8649;
+$violet: #af88eb;
+
+$br_red: #ff665c;
+$br_green: #84c747;
+$br_yellow: #ebc13d;
+$br_blue: #58a3ff;
+$br_magenta: #ff84cd;
+$br_cyan: #53d6c7;
+$br_orange: #fd9456;
+$br_violet: #bd96fa;
+
+$accent_primary: $blue;
+$accent_secondary: $magenta;
+$accent_tertiary: $cyan;
+$accent_success: $green;
+$accent_warning: $yellow;
+$accent_error: $red;
+
+/* === GLOBAL STYLES === */
+Screen {
+    background: $bg_0;
+    color: $fg_0;
+}
+
+/* === HEADER & FOOTER === */
+Header {
+    background: $bg_1;
+    color: $fg_1;
+    border-bottom: solid $blue;
+    text-style: bold;
+}
+
+Footer {
+    background: $bg_1;
+    color: $fg_1;
+    border-top: solid $blue;
+}
+
+/* === STATUS BAR === */
+#stats_container {
+    height: auto;
+    margin: 1 0;
+}
+
+#status_bar {
+    background: $bg_2;
+    color: $fg_1;
+    height: 3;
+    padding: 0 2;
+    border: solid $dim_0;
+    margin: 0 1;
+    text-style: bold;
+}
+
+/* === LAYOUT CONTAINERS === */
+Vertical {
+    width: 100%;
+    height: 1fr;
+    padding: 0 1;
+}
+
+/* === DATA TABLE STYLING === */
+DataTable {
+    background: $bg_0;
+    color: $fg_0;
+    width: 100%;
+    height: 1fr;
+    border: solid $dim_0;
+    margin: 1 0;
+}
+
+DataTable .header {
+    background: $bg_1;
+    color: $fg_1;
+    text-style: bold;
+    height: 3;
+    border-bottom: solid $blue;
+}
+
+DataTable .datatable--cursor {
+    background: $blue;
+    color: $bg_0;
+    text-style: bold;
+}
+
+DataTable .datatable--hover {
+    background: $bg_2;
+    color: $fg_1;
+}
+
+DataTable:focus .datatable--cursor {
+    background: $br_blue;
+    text-style: bold;
+}
+
+/* === DETAIL SCREEN STYLING === */
+#detail_title {
+    background: $bg_2;
+    color: $fg_1;
+    height: 4;
+    padding: 1 2;
+    text-align: center;
+    text-style: bold;
+    margin: 1 0 2 0;
+    border: solid $blue;
+}
+
+#main_content {
+    height: auto;
+    margin: 0 2;
+}
+
+#connection_details, #process_info {
+    background: $bg_1;
+    padding: 2;
+    margin: 0 1 2 0;
+    border: solid $dim_0;
+    height: auto;
+    width: 1fr;
+}
+
+.section_header {
+    background: $bg_2;
+    color: $fg_1;
+    padding: 1 2;
+    text-align: center;
+    text-style: bold;
+    margin: 0 0 1 0;
+    height: 3;
+    border: solid $cyan;
+}
+
+.detail_title {
+    margin: 0 0 1 0;
+    padding: 0 1;
+    color: $fg_1;
+    text-style: bold;
+    border-bottom: solid $cyan;
+}
+
+.detail_item {
+    margin: 0 0 1 0;
+    padding: 0 1;
+    color: $fg_0;
+    border-left: solid $cyan;
+    padding-left: 2;
+}
+
+.detail_item:hover {
+    color: $fg_1;
+    background: $bg_2;
+}
+
+/* === BUTTONS === */
+#button_container {
+    align: center middle;
+    height: auto;
+    margin: 2 0;
+}
+
+#back_button {
+    background: $blue;
+    color: $bg_0;
+    border: solid $blue;
+    width: 25;
+    height: 3;
+    text-style: bold;
+}
+
+#back_button:hover {
+    background: $br_blue;
+    border: solid $br_blue;
+}
+
+#back_button:focus {
+    background: $cyan;
+    border: solid $cyan;
+}
+
+Button:focus {
+    border: solid $blue;
+}
+
+/* === SCROLLABLE CONTAINERS === */
+ScrollableContainer {
+    background: transparent;
+    scrollbar-background: $bg_1;
+    scrollbar-color: $blue;
+    scrollbar-color-hover: $br_blue;
+    scrollbar-color-active: $cyan;
+}
+
+/* === CONNECTION STATUS INDICATORS === */
+.status-ESTABLISHED {
+    color: $green;
+    text-style: bold;
+}
+
+.status-LISTEN {
+    color: $blue;
+    text-style: bold;
+}
+
+.status-TIME_WAIT {
+    color: $yellow;
+}
+
+.status-CLOSE_WAIT {
+    color: $red;
+}
+
+/* === ACCESSIBILITY === */
+*:focus {
+    outline: solid $blue;
+}
+"""

netshow-0.1.1.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: netshow
+Version: 0.1.1
+Summary: A real-time network connection monitor with friendly service names
+Author: Taylor Wilsdon
+License: MIT
+License-File: LICENSE
+Keywords: connections,monitoring,network,tui
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Networking :: Monitoring
+Requires-Python: >=3.9
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: textual>=0.40.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Requires-Dist: types-psutil>=5.9.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<h1 align="center">🚦 NetShow</h1>
+<p align="center"><em>Friendly, process-aware network monitoring for your terminal</em></p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/python-3.9%2B-blue?logo=python&logoColor=white" alt="Python versions">
+  <img src="https://img.shields.io/github/license/taylorwilsdon/netshow?color=green" alt="License">
+  <img src="https://img.shields.io/badge/platform-macOS%20%7C%20Linux-lightgrey" alt="Platform">
+  <img src="https://img.shields.io/badge/code%20style-ruff-black?logo=ruff" alt="Code style: ruff">
+  <img src="https://img.shields.io/badge/UI-Textual-purple" alt="Built with Textual">
+  <img src="https://img.shields.io/badge/dependencies-uv-orange?logo=uv" alt="uv">
+</p>
+
+<div align="center">
+  <video width="1012px" src="https://github.com/user-attachments/assets/97f5af92-ec0a-4243-9894-d0c9d9470e1a"></video>
+</div>
+
+---
+
+<details>
+<summary><strong>Table&nbsp;of&nbsp;Contents</strong></summary>
+
+- [Features](#features)
+- [Quickstart](#quickstart)
+- [Usage](#usage)
+- [Keybindings](#keybindings)
+- [Development](#development)
+- [Requirements](#requirements)
+- [Contributing](#contributing)
+- [License](#license)
+</details>
+
+---
+
+## ✨ Features
+
+| Capability | Details |
+|------------|---------|
+| **Live TCP monitor** | Refreshes every 3 s (configurable) while preserving scroll position |
+| **Human-friendly service names** | Shows *Docker*, *Plex*, *VS Code*, etc. instead of cryptic binaries |
+| **Deep process drill-down** | Path, PID, cmdline, cwd, threads, CPU %, memory %, open files, active connections |
+| **Clickable / keyboard navigation** | Press `↵` or click a row for a dedicated detail screen; refresh pauses automatically |
+| **Runs privileged <br>or unprivileged** | Uses `psutil` (root) for full fidelity, falls back to `lsof` if run as a regular user |
+| **Modern Textual UI** | Smooth scrolling, dark theme, status bar with connection count & data source |
+| **Zero-pain install** | Powered by [`uv`](https://github.com/astral-sh/uv) for lightning-fast dependency resolution |
+
+---
+
+## 🚀 Quickstart
+
+```bash
+# Install (recommended)
+uv pip install netshow
+
+# Run
+netshow
+````
+
+> **Tip:** Without root/sudo, NetShow silently switches to `lsof` and still gives you most connections.
+
+---
+
+## 🛠️ Usage
+
+```bash
+netshow [--interval 1.0] [--no-colors]
+```
+
+| Option             | Description          | Default |
+| ------------------ | -------------------- | ------- |
+| `--interval <sec>` | Refresh rate (float) | `3.0`   |
+| `--no-colors`      | Disable ANSI colors  | Off     |
+
+### Keybindings
+
+| Key / Mouse | Action           |
+| ----------- | ---------------- |
+| ↑ / ↓       | Move cursor      |
+| ↵ / Click   | Open detail view |
+| Esc / ←     | Back to list     |
+| **q**       | Quit NetShow     |
+
+---
+
+## 👩‍💻 Development
+
+```bash
+git clone https://github.com/taylorwilsdon/netshow.git
+cd netshow
+uv sync --extra dev
+```
+
+### Quality Gates
+
+```bash
+pytest            # tests
+ruff format .     # auto-format
+ruff check .      # lint
+mypy src/         # type check
+```
+
+---
+
+## 📋 Requirements
+
+* Python **≥ 3.9**
+* macOS or Linux
+* `lsof` (usually pre-installed)
+
+---
+
+## 🤝 Contributing
+
+Pull requests and ⭐ stars are welcome! Found a bug or have a feature request? Please [open an issue](https://github.com/taylorwilsdon/netshow/issues).
+
+---
+
+## 📜 License
+
+MIT – see [`LICENSE`](LICENSE) for full text.
+

netshow-0.1.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+netshow/__init__.py,sha256=Ii5MvKekxwbMOFspk84VayHSrNbacGOtSpEw8cUmMz8,107
+netshow/app.py,sha256=jozqlrDRtuswkOi71zm51a2wySJylH4ZCmg6eRtucSQ,14494
+netshow/cli.py,sha256=Gf2bP_jkcXHjG6TBnP-gd3t5EfzdAr_lgNahN6j60Ik,256
+netshow/helpers.py,sha256=dkbxdtQnXGv8k7-J9c9ZtM4OFmYw9a91lL44g4xT4Vc,4139
+netshow/styles.py,sha256=8ljAqE3UpWPdWzdwOTw8I18-UULsT6LOo7lMQwtFLSY,3786
+netshow-0.1.1.dist-info/METADATA,sha256=NhIsGKeokJ6-4y_x-debaVboZOsCPa1VX5SUODFJzsc,4662
+netshow-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+netshow-0.1.1.dist-info/entry_points.txt,sha256=UYD75nElh3HHMSzxCSG7q-BqrgsbELsTU6jrzD0yOw4,45
+netshow-0.1.1.dist-info/licenses/LICENSE,sha256=hFwE7mP1CbnwuyD3PdviRJ5AmeIMnu5sCq52Two_Rnc,1120
+netshow-0.1.1.dist-info/RECORD,,

netshow-0.1.1.dist-info/WHEEL

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

netshow-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+netshow = netshow.cli:main

netshow-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+(base) ➜  reddacted git:(main) ✗ cat LICENSE
+MIT License
+
+Copyright (c) 2025 Taylor Wilsdon
+
+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.