netshow 0.2.0__tar.gz → 0.2.2__tar.gz

{netshow-0.2.0 → netshow-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netshow
-Version: 0.2.0
+Version: 0.2.2
 Summary: A real-time network connection monitor with friendly service names
 Author: Taylor Wilsdon
 License: MIT
@@ -45,19 +45,21 @@ Description-Content-Type: text/markdown
 ---
 
 <div align="center" width="600px">
-  <video width="600px" src="https://github.com/user-attachments/assets/97f5af92-ec0a-4243-9894-d0c9d9470e1a"></video>
+  <video width="600px" src="https://github.com/user-attachments/assets/e110f7db-f803-4aad-bef8-c3e928eed6e5"></video>
 </div>
 
 ---
 
 ### A quick plug for AI-Enhanced Docs
+<details>
+<summary>But why?</summary>
 
-> **This README was crafted with AI assistance, and here's why that matters**
-> 
-> As a solo developer building open source tools that may only ever serve my own needs, comprehensive documentation often wouldn't happen without AI help. Using agentic dev tools like **Roo** & **Claude Code** that understand the entire codebase, AI doesn't just regurgitate generic content - it extracts real implementation details and creates accurate, specific documentation.
+**This README was written with AI assistance, and here's why that matters**
 >
-> In this case, Sonnet 4 took a pass & a human (me) verified them 6/28/25.
- 
+> As a solo dev building open source tools that many never see outside use, comprehensive documentation often wouldn't happen without AI help. Using agentic dev tools like **Roo** & **Claude Code** that understand the entire codebase, AI doesn't just regurgitate generic content - it extracts real implementation details and creates accurate, specific documentation.
+>
+> In this case, Sonnet 4 took a pass & a human (me) verified them 7/10/25.
+</details>
 
 ## ✨ **Features**
 
@@ -143,6 +145,7 @@ netshow [--interval 1.0] [--no-colors]
 | **q** | Quit NetShow |
 | **Ctrl+C** | Force quit (hard quit) |
 | **Ctrl+R** | Force refresh |
+| **e** | Toggle emoji display on/off |
 | **f** | Toggle filter input |
 | **/** | Quick search (focus filter) |
 | **s** | Sort by connection status |
@@ -157,6 +160,12 @@ netshow [--interval 1.0] [--no-colors]
 - Filters across process names, addresses, and connection status
 - Live updates as you type (with debouncing)
 
+**🎨 Emoji Toggle**
+- Press `e` to toggle emoji display on/off for a cleaner interface
+- When disabled, removes all emoji prefixes from UI elements
+- Useful for terminals with limited emoji support or accessibility preferences
+- Setting persists during the session
+
 **📊 Bandwidth Monitoring**
 - Real-time bandwidth display in the metrics bar
 - Press `i` to cycle through network interfaces (`all`, `eth0`, `wlan0`, etc.)

{netshow-0.2.0 → netshow-0.2.2}/README.md

@@ -13,19 +13,21 @@
 ---
 
 <div align="center" width="600px">
-  <video width="600px" src="https://github.com/user-attachments/assets/97f5af92-ec0a-4243-9894-d0c9d9470e1a"></video>
+  <video width="600px" src="https://github.com/user-attachments/assets/e110f7db-f803-4aad-bef8-c3e928eed6e5"></video>
 </div>
 
 ---
 
 ### A quick plug for AI-Enhanced Docs
+<details>
+<summary>But why?</summary>
 
-> **This README was crafted with AI assistance, and here's why that matters**
-> 
-> As a solo developer building open source tools that may only ever serve my own needs, comprehensive documentation often wouldn't happen without AI help. Using agentic dev tools like **Roo** & **Claude Code** that understand the entire codebase, AI doesn't just regurgitate generic content - it extracts real implementation details and creates accurate, specific documentation.
+**This README was written with AI assistance, and here's why that matters**
 >
-> In this case, Sonnet 4 took a pass & a human (me) verified them 6/28/25.
- 
+> As a solo dev building open source tools that many never see outside use, comprehensive documentation often wouldn't happen without AI help. Using agentic dev tools like **Roo** & **Claude Code** that understand the entire codebase, AI doesn't just regurgitate generic content - it extracts real implementation details and creates accurate, specific documentation.
+>
+> In this case, Sonnet 4 took a pass & a human (me) verified them 7/10/25.
+</details>
 
 ## ✨ **Features**
 
@@ -111,6 +113,7 @@ netshow [--interval 1.0] [--no-colors]
 | **q** | Quit NetShow |
 | **Ctrl+C** | Force quit (hard quit) |
 | **Ctrl+R** | Force refresh |
+| **e** | Toggle emoji display on/off |
 | **f** | Toggle filter input |
 | **/** | Quick search (focus filter) |
 | **s** | Sort by connection status |
@@ -125,6 +128,12 @@ netshow [--interval 1.0] [--no-colors]
 - Filters across process names, addresses, and connection status
 - Live updates as you type (with debouncing)
 
+**🎨 Emoji Toggle**
+- Press `e` to toggle emoji display on/off for a cleaner interface
+- When disabled, removes all emoji prefixes from UI elements
+- Useful for terminals with limited emoji support or accessibility preferences
+- Setting persists during the session
+
 **📊 Bandwidth Monitoring**
 - Real-time bandwidth display in the metrics bar
 - Press `i` to cycle through network interfaces (`all`, `eth0`, `wlan0`, etc.)

netshow-0.2.2/how_to_per_proc_bw.md

@@ -0,0 +1,384 @@
+# The Definitive Guide to Per-Process Bandwidth Monitoring with Python
+
+## Overview
+
+Per-process bandwidth monitoring tracks network usage by individual processes, enabling you to identify which applications consume the most bandwidth. This guide covers cross-platform solutions that work on both macOS and Linux.
+
+## Core Approaches
+
+### 1. **System-Level Tools with Python Wrappers**
+
+The most reliable approach leverages existing system monitoring tools through Python subprocess calls.
+
+#### **Linux: nethogs**
+```python
+import subprocess
+import re
+import json
+
+class NethogsBandwidthMonitor:
+    def __init__(self):
+        self.process = None
+    
+    def start_monitoring(self, interface='eth0'):
+        """Start nethogs in JSON mode for easy parsing"""
+        cmd = ['sudo', 'nethogs', '-t', '-d', '1', interface]
+        self.process = subprocess.Popen(
+            cmd, 
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True
+        )
+    
+    def parse_output(self):
+        """Parse nethogs output and return bandwidth data"""
+        bandwidth_data = {}
+        
+        for line in self.process.stdout:
+            # Format: program/pid/uid  sent_kb/s  recv_kb/s
+            match = re.match(r'(\S+)/(\d+)/(\d+)\s+([\d.]+)\s+([\d.]+)', line)
+            if match:
+                program, pid, uid, sent, recv = match.groups()
+                bandwidth_data[pid] = {
+                    'program': program,
+                    'sent_kbps': float(sent),
+                    'recv_kbps': float(recv),
+                    'total_kbps': float(sent) + float(recv)
+                }
+        
+        return bandwidth_data
+```
+
+#### **macOS: nettop**
+```python
+import subprocess
+import re
+
+class NettopBandwidthMonitor:
+    def __init__(self):
+        self.last_values = {}
+    
+    def get_bandwidth(self):
+        """Get current bandwidth usage per process"""
+        cmd = ['nettop', '-P', '-L', '1', '-J', 'bytes_in,bytes_out']
+        
+        try:
+            output = subprocess.check_output(cmd, text=True)
+            return self._parse_nettop_output(output)
+        except subprocess.CalledProcessError as e:
+            print(f"Error running nettop: {e}")
+            return {}
+    
+    def _parse_nettop_output(self, output):
+        """Parse nettop output"""
+        bandwidth_data = {}
+        
+        for line in output.split('\n'):
+            if '.' in line and 'bytes' not in line.lower():
+                parts = line.split(',')
+                if len(parts) >= 3:
+                    process_info = parts[0].strip()
+                    bytes_in = int(parts[1].strip())
+                    bytes_out = int(parts[2].strip())
+                    
+                    # Extract PID from process info
+                    pid_match = re.search(r'\.(\d+)', process_info)
+                    if pid_match:
+                        pid = pid_match.group(1)
+                        bandwidth_data[pid] = {
+                            'process': process_info.split('.')[0],
+                            'bytes_in': bytes_in,
+                            'bytes_out': bytes_out,
+                            'total_bytes': bytes_in + bytes_out
+                        }
+        
+        return bandwidth_data
+```
+
+### 2. **psutil-based Solution**
+
+A more portable but less accurate approach uses psutil to track network connections per process.
+
+```python
+import psutil
+import time
+from collections import defaultdict
+
+class PsutilBandwidthMonitor:
+    def __init__(self):
+        self.last_io_counters = {}
+        self.connection_map = defaultdict(set)
+    
+    def update_connections(self):
+        """Map network connections to processes"""
+        self.connection_map.clear()
+        
+        for conn in psutil.net_connections(kind='inet'):
+            if conn.pid:
+                self.connection_map[conn.pid].add(
+                    (conn.laddr, conn.raddr, conn.status)
+                )
+    
+    def estimate_bandwidth(self, interval=1.0):
+        """Estimate bandwidth by monitoring system-wide changes"""
+        # Get initial network stats
+        net_io_1 = psutil.net_io_counters()
+        proc_io_1 = {}
+        
+        for proc in psutil.process_iter(['pid', 'name']):
+            try:
+                proc_io_1[proc.pid] = proc.io_counters()
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+        
+        time.sleep(interval)
+        
+        # Get final network stats
+        net_io_2 = psutil.net_io_counters()
+        bandwidth_data = {}
+        
+        for proc in psutil.process_iter(['pid', 'name']):
+            try:
+                if proc.pid in proc_io_1:
+                    io_2 = proc.io_counters()
+                    io_1 = proc_io_1[proc.pid]
+                    
+                    # Calculate I/O delta (approximation)
+                    read_delta = io_2.read_bytes - io_1.read_bytes
+                    write_delta = io_2.write_bytes - io_1.write_bytes
+                    
+                    # Only include if process has network connections
+                    if proc.pid in self.connection_map:
+                        bandwidth_data[proc.pid] = {
+                            'name': proc.name(),
+                            'connections': len(self.connection_map[proc.pid]),
+                            'read_bytes_sec': read_delta / interval,
+                            'write_bytes_sec': write_delta / interval
+                        }
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+        
+        return bandwidth_data
+```
+
+### 3. **eBPF-based Solution (Linux only)**
+
+For the most accurate Linux monitoring, use eBPF with Python bindings.
+
+```python
+from bcc import BPF
+import time
+
+# eBPF program to track network bytes per PID
+bpf_program = """
+#include <uapi/linux/ptrace.h>
+#include <net/sock.h>
+#include <bcc/proto.h>
+
+BPF_HASH(pid_bytes, u32, u64);
+
+int trace_tcp_sendmsg(struct pt_regs *ctx, struct sock *sk,
+                      struct msghdr *msg, size_t size) {
+    u32 pid = bpf_get_current_pid_tgid() >> 32;
+    u64 *bytes = pid_bytes.lookup(&pid);
+    if (bytes) {
+        *bytes += size;
+    } else {
+        pid_bytes.update(&pid, &size);
+    }
+    return 0;
+}
+"""
+
+class EBPFBandwidthMonitor:
+    def __init__(self):
+        self.bpf = BPF(text=bpf_program)
+        self.bpf.attach_kprobe(event="tcp_sendmsg", fn_name="trace_tcp_sendmsg")
+        self.last_values = {}
+    
+    def get_bandwidth_stats(self, interval=1.0):
+        """Get bandwidth usage per PID"""
+        time.sleep(interval)
+        
+        bandwidth_data = {}
+        pid_bytes = self.bpf["pid_bytes"]
+        
+        for k, v in pid_bytes.items():
+            pid = k.value
+            bytes_sent = v.value
+            
+            if pid in self.last_values:
+                bytes_per_sec = (bytes_sent - self.last_values[pid]) / interval
+                bandwidth_data[pid] = {
+                    'bytes_per_sec': bytes_per_sec,
+                    'mbps': (bytes_per_sec * 8) / 1_000_000
+                }
+            
+            self.last_values[pid] = bytes_sent
+        
+        return bandwidth_data
+```
+
+## Unified Cross-Platform Interface
+
+```python
+import platform
+import os
+
+class BandwidthMonitor:
+    def __init__(self):
+        self.system = platform.system()
+        self.monitor = None
+        self._initialize_monitor()
+    
+    def _initialize_monitor(self):
+        """Initialize the appropriate monitor for the current OS"""
+        if self.system == 'Linux':
+            # Check for available tools
+            if os.path.exists('/usr/sbin/nethogs'):
+                self.monitor = NethogsBandwidthMonitor()
+            else:
+                # Fallback to psutil
+                self.monitor = PsutilBandwidthMonitor()
+        elif self.system == 'Darwin':  # macOS
+            self.monitor = NettopBandwidthMonitor()
+        else:
+            # Default fallback
+            self.monitor = PsutilBandwidthMonitor()
+    
+    def get_process_bandwidth(self, interval=1.0):
+        """Get bandwidth data for all processes"""
+        if hasattr(self.monitor, 'get_bandwidth'):
+            return self.monitor.get_bandwidth()
+        elif hasattr(self.monitor, 'estimate_bandwidth'):
+            return self.monitor.estimate_bandwidth(interval)
+        else:
+            raise NotImplementedError("No bandwidth monitoring available")
+    
+    def format_output(self, bandwidth_data, top_n=10):
+        """Format bandwidth data for display"""
+        # Sort by total bandwidth
+        sorted_procs = sorted(
+            bandwidth_data.items(),
+            key=lambda x: x[1].get('total_bytes', 0) or 
+                         x[1].get('total_kbps', 0) or 0,
+            reverse=True
+        )[:top_n]
+        
+        print(f"{'PID':<8} {'Process':<25} {'Download':<15} {'Upload':<15}")
+        print("-" * 70)
+        
+        for pid, data in sorted_procs:
+            process_name = data.get('name', data.get('program', 'Unknown'))[:24]
+            
+            # Handle different data formats
+            if 'recv_kbps' in data:
+                download = f"{data['recv_kbps']:.2f} KB/s"
+                upload = f"{data['sent_kbps']:.2f} KB/s"
+            elif 'bytes_in' in data:
+                download = f"{data['bytes_in'] / 1024:.2f} KB"
+                upload = f"{data['bytes_out'] / 1024:.2f} KB"
+            else:
+                download = f"{data.get('read_bytes_sec', 0) / 1024:.2f} KB/s"
+                upload = f"{data.get('write_bytes_sec', 0) / 1024:.2f} KB/s"
+            
+            print(f"{pid:<8} {process_name:<25} {download:<15} {upload:<15}")
+```
+
+## Usage Example
+
+```python
+def main():
+    monitor = BandwidthMonitor()
+    
+    print("Starting bandwidth monitoring...")
+    print("Press Ctrl+C to stop\n")
+    
+    try:
+        while True:
+            bandwidth_data = monitor.get_process_bandwidth(interval=2.0)
+            
+            # Clear screen (works on most terminals)
+            print("\033[2J\033[H")
+            
+            # Display current bandwidth usage
+            monitor.format_output(bandwidth_data, top_n=15)
+            
+            time.sleep(2)
+            
+    except KeyboardInterrupt:
+        print("\nMonitoring stopped.")
+
+if __name__ == "__main__":
+    main()
+```
+
+## Installation Requirements
+
+### **Linux**
+```bash
+# For nethogs approach
+sudo apt-get install nethogs  # Debian/Ubuntu
+sudo yum install nethogs      # RHEL/CentOS
+
+# For eBPF approach
+pip install bcc
+
+# For psutil approach
+pip install psutil
+```
+
+### **macOS**
+```bash
+# nettop comes pre-installed
+# For psutil approach
+pip install psutil
+```
+
+## Important Considerations
+
+1. **Permissions**: Most accurate monitoring requires root/sudo access
+2. **Accuracy**: System tools (nethogs, nettop) are most accurate; psutil provides estimates
+3. **Performance**: eBPF has minimal overhead; subprocess calls have higher overhead
+4. **Portability**: psutil works everywhere but with reduced accuracy
+
+## Advanced Features
+
+### Real-time Graphing
+```python
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from collections import deque
+
+class BandwidthGraph:
+    def __init__(self, monitor, max_points=60):
+        self.monitor = monitor
+        self.max_points = max_points
+        self.data = defaultdict(lambda: deque(maxlen=max_points))
+        
+        self.fig, self.ax = plt.subplots()
+        self.lines = {}
+    
+    def update(self, frame):
+        bandwidth_data = self.monitor.get_process_bandwidth()
+        
+        for pid, data in bandwidth_data.items():
+            total_kbps = data.get('total_kbps', 0)
+            self.data[pid].append(total_kbps)
+            
+            if pid not in self.lines:
+                line, = self.ax.plot([], [], label=f"PID {pid}")
+                self.lines[pid] = line
+            
+            self.lines[pid].set_data(range(len(self.data[pid])), self.data[pid])
+        
+        self.ax.relim()
+        self.ax.autoscale_view()
+        self.ax.legend()
+        
+    def start(self):
+        ani = FuncAnimation(self.fig, self.update, interval=1000)
+        plt.show()
+```
+
+This guide provides a comprehensive foundation for implementing per-process bandwidth monitoring across platforms, with multiple approaches ranging from simple to advanced, ensuring you can track network usage effectively regardless of your specific requirements or constraints.

{netshow-0.2.0 → netshow-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "netshow"
-version = "0.2.0"
+version = "0.2.2"
 description = "A real-time network connection monitor with friendly service names"
 readme = "README.md"
 requires-python = ">=3.9"

{netshow-0.2.0 → netshow-0.2.2}/src/netshow/app.py

@@ -1,277 +1,23 @@
 import os
 import time
-from typing import Any, Optional, TypedDict, Union, cast
+from typing import Any, Optional, Union, cast
 
 import psutil
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.containers import (
-    Container,
-    Horizontal,
-    ScrollableContainer,
-    Vertical,
-)
+from textual.containers import Container, Horizontal, Vertical
 from textual.reactive import reactive
-from textual.screen import Screen
 from textual.timer import Timer
-from textual.widgets import (
-    Button,
-    DataTable,
-    Footer,
-    Header,
-    Input,
-    Static,
-)
+from textual.widgets import DataTable, Footer, Header, Input, Static
 
+from .detail_screen import ConnectionDetailScreen
 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"]
-BASIC_KEYBINDINGS = [
-    ("q", "quit", "Quit"),
-    ("ctrl+r", "refresh", "Force Refresh"),
-    ("f", "toggle_filter", "Filter"),
-    ("s", "sort_by_status", "Sort by Status"),
-    ("p", "sort_by_process", "Sort by Process"),
-    ("i", "toggle_interface", "Interface"),
-    ("e", "toggle_emojis", "Emojis"),
-    ("ctrl+c", "quit", "Hard Quit"),
-    ("/", "search", "Search"),
-]
-
-
-class ConnectionData(TypedDict):
-    """Type definition for connection data."""
-
-    pid: str
-    friendly: str
-    proc: str
-    laddr: str
-    raddr: str
-    status: str
-
-
-class NetworkStats(TypedDict):
-    """Type definition for network statistics."""
-
-    total_connections: int
-    established: int
-    listening: int
-    time_wait: int
-    bytes_sent: int
-    bytes_recv: int
-    packets_sent: int
-    packets_recv: int
-    timestamp: float
-
-
-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."""
-        # Check if parent app has emoji toggle disabled
-        if hasattr(self.app, "show_emojis") and not self.app.show_emojis:
-            return ""
-        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():
-            # Check emoji setting from parent app
-            show_emojis = getattr(self.app, "show_emojis", True)
-            title_prefix = "🔗 " if show_emojis else ""
-            yield Static(
-                f"{title_prefix}Connection Details: {self.connection_data['friendly']}",
-                id="detail_title",
-            )
-
-            with Horizontal(id="main_content"):
-                with Container(id="connection_details"):
-                    conn_prefix = "🌐 " if show_emojis else ""
-                    pid_prefix = "🆔 " if show_emojis else ""
-                    proc_prefix = "⚙️ " if show_emojis else ""
-                    friendly_prefix = "🏷️  " if show_emojis else ""
-                    local_prefix = "🏠 " if show_emojis else ""
-                    remote_prefix = "🌐 " if show_emojis else ""
-
-                    yield Static(
-                        f"{conn_prefix}Connection Info", classes="detail_title"
-                    )
-                    yield Static(
-                        f"{pid_prefix}PID: {self.connection_data['pid']}",
-                        classes="detail_item",
-                    )
-                    yield Static(
-                        f"{proc_prefix}Process: {self.connection_data['proc']}",
-                        classes="detail_item",
-                    )
-                    yield Static(
-                        f"{friendly_prefix}Friendly Name: {self.connection_data['friendly']}",
-                        classes="detail_item",
-                    )
-                    yield Static(
-                        f"{local_prefix}Local Address: {self.connection_data['laddr']}",
-                        classes="detail_item",
-                        markup=False,
-                    )
-                    yield Static(
-                        f"{remote_prefix}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"):
-                        process_title_prefix = "🔧 " if show_emojis else ""
-                        exe_prefix = "📁 " if show_emojis else ""
-                        cmd_prefix = "💻 " if show_emojis else ""
-                        status_prefix = "📊 " if show_emojis else ""
-                        user_prefix = "👤 " if show_emojis else ""
-                        cwd_prefix = "📂 " if show_emojis else ""
-                        threads_prefix = "🧵 " if show_emojis else ""
-
-                        yield Static(
-                            f"{process_title_prefix}Process Details",
-                            classes="detail_title",
-                        )
-                        yield Static(
-                            f"{exe_prefix}Executable: {self.process_info.get('exe', 'N/A')}",
-                            classes="detail_item",
-                        )
-                        yield Static(
-                            f"{cmd_prefix}Command Line: {self.process_info.get('cmd', 'N/A')}",
-                            classes="detail_item",
-                        )
-                        yield Static(
-                            f"{status_prefix}Status: {self.process_info.get('status', 'N/A')}",
-                            classes="detail_item",
-                        )
-                        yield Static(
-                            f"{user_prefix}User: {self.process_info.get('username', 'N/A')}",
-                            classes="detail_item",
-                        )
-                        yield Static(
-                            f"{cwd_prefix}Working Directory: {self.process_info.get('cwd', 'N/A')}",
-                            classes="detail_item",
-                        )
-                        yield Static(
-                            f"{threads_prefix}Threads: "
-                            f"{self.process_info.get('num_threads', 'N/A')}",
-                            classes="detail_item",
-                        )
-
-                        cpu_percent = self.process_info.get("cpu_percent", 0.0)
-                        if show_emojis:
-                            cpu_icon = (
-                                "🔥"
-                                if cpu_percent > 50
-                                else "⚡" if cpu_percent > 10 else "💤"
-                            )
-                        else:
-                            cpu_icon = ""
-                        cpu_prefix = f"{cpu_icon} " if cpu_icon else ""
-                        yield Static(
-                            f"{cpu_prefix}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"
-                        )
-                        if show_emojis:
-                            memory_icon = (
-                                "🚨"
-                                if memory_percent > 80
-                                else "⚠️" if memory_percent > 50 else "💾"
-                            )
-                        else:
-                            memory_icon = ""
-                        memory_prefix = f"{memory_icon} " if memory_icon else ""
-                        yield Static(
-                            f"{memory_prefix}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
-                            )
-                            active_conn_prefix = "🌐 " if show_emojis else ""
-                            yield Static(
-                                f"{active_conn_prefix}Active Connections: {conn_count}",
-                                classes="detail_item",
-                            )
-
-            with Container(id="button_container"):
-                back_prefix = "🔙 " if show_emojis else ""
-                yield Button(f"{back_prefix}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()
+from .types_and_constants import (
+    BASIC_KEYBINDINGS,
+    REFRESH_INTERVAL,
+    ConnectionData,
+)
 
 
 class NetshowApp(App):
@@ -743,6 +489,12 @@ class NetshowApp(App):
         # Reset bandwidth stats when changing interface
         self.last_network_stats = None
         self.last_stats_time = None
+        self.refresh_connections()
+
+        # Update metrics display immediately
+        self._update_metrics_display(
+            self.total_connections, self.active_connections, self.listening_connections
+        )
 
     def action_toggle_emojis(self) -> None:
         """Toggle emoji display on/off."""

netshow-0.2.2/src/netshow/detail_screen.py

@@ -0,0 +1,223 @@
+from typing import Optional
+
+import psutil
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, ScrollableContainer
+from textual.screen import Screen
+from textual.widgets import Button, Header, Static
+
+from .types_and_constants import ConnectionData
+
+
+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.proc: Optional[psutil.Process] = None
+        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."""
+        # Check if parent app has emoji toggle disabled
+        if hasattr(self.app, "show_emojis") and not self.app.show_emojis:
+            return ""
+        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)
+            if self.proc is None:
+                self.proc = psutil.Process(pid)
+                self.proc.cpu_percent()  # Initialize CPU percent baseline
+
+            # Type guard to ensure mypy understands proc is not None
+            assert self.proc is not None
+
+            return {
+                "name": self.proc.name(),
+                "exe": self.proc.exe(),
+                "cmd": " ".join(self.proc.cmdline()),
+                "create_time": self.proc.create_time(),
+                "status": self.proc.status(),
+                "username": self.proc.username(),
+                "cwd": self.proc.cwd(),
+                "num_threads": self.proc.num_threads(),
+                "cpu_percent": self.proc.cpu_percent(),
+                "memory_percent": self.proc.memory_percent(),
+                "open_files": self.proc.open_files(),
+                "connections": self.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():
+            # Check emoji setting from parent app
+            show_emojis = getattr(self.app, "show_emojis", True)
+            title_prefix = "🔗 " if show_emojis else ""
+            yield Static(
+                f"{title_prefix}Connection Details: {self.connection_data['friendly']}",
+                id="detail_title",
+            )
+
+            with Horizontal(id="main_content"):
+                with Container(id="connection_details"):
+                    conn_prefix = "🌐 " if show_emojis else ""
+                    pid_prefix = "🆔 " if show_emojis else ""
+                    proc_prefix = "⚙️ " if show_emojis else ""
+                    friendly_prefix = "🏷️  " if show_emojis else ""
+                    local_prefix = "🏠 " if show_emojis else ""
+                    remote_prefix = "🌐 " if show_emojis else ""
+
+                    yield Static(
+                        f"{conn_prefix}Connection Info", classes="detail_title"
+                    )
+                    yield Static(
+                        f"{pid_prefix}PID: {self.connection_data['pid']}",
+                        classes="detail_item",
+                    )
+                    yield Static(
+                        f"{proc_prefix}Process: {self.connection_data['proc']}",
+                        classes="detail_item",
+                    )
+                    yield Static(
+                        f"{friendly_prefix}Friendly Name: {self.connection_data['friendly']}",
+                        classes="detail_item",
+                    )
+                    yield Static(
+                        f"{local_prefix}Local Address: {self.connection_data['laddr']}",
+                        classes="detail_item",
+                        markup=False,
+                    )
+                    yield Static(
+                        f"{remote_prefix}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"):
+                        process_title_prefix = "🔧 " if show_emojis else ""
+                        exe_prefix = "📁 " if show_emojis else ""
+                        cmd_prefix = "💻 " if show_emojis else ""
+                        status_prefix = "📊 " if show_emojis else ""
+                        user_prefix = "👤 " if show_emojis else ""
+                        cwd_prefix = "📂 " if show_emojis else ""
+                        threads_prefix = "🧵 " if show_emojis else ""
+
+                        yield Static(
+                            f"{process_title_prefix}Process Details",
+                            classes="detail_title",
+                        )
+                        yield Static(
+                            f"{exe_prefix}Executable: {self.process_info.get('exe', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"{cmd_prefix}Command Line: {self.process_info.get('cmd', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"{status_prefix}Status: {self.process_info.get('status', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"{user_prefix}User: {self.process_info.get('username', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"{cwd_prefix}Working Directory: {self.process_info.get('cwd', 'N/A')}",
+                            classes="detail_item",
+                        )
+                        yield Static(
+                            f"{threads_prefix}Threads: "
+                            f"{self.process_info.get('num_threads', 'N/A')}",
+                            classes="detail_item",
+                        )
+
+                        cpu_percent = self.process_info.get("cpu_percent", 0.0)
+                        if show_emojis:
+                            cpu_icon = (
+                                "🔥"
+                                if cpu_percent > 50
+                                else "⚡" if cpu_percent > 10 else "💤"
+                            )
+                        else:
+                            cpu_icon = ""
+                        cpu_prefix = f"{cpu_icon} " if cpu_icon else ""
+                        yield Static(
+                            f"{cpu_prefix}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"
+                        )
+                        if show_emojis:
+                            memory_icon = (
+                                "🚨"
+                                if memory_percent > 80
+                                else "⚠️" if memory_percent > 50 else "💾"
+                            )
+                        else:
+                            memory_icon = ""
+                        memory_prefix = f"{memory_icon} " if memory_icon else ""
+                        yield Static(
+                            f"{memory_prefix}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
+                            )
+                            active_conn_prefix = "🌐 " if show_emojis else ""
+                            yield Static(
+                                f"{active_conn_prefix}Active Connections: {conn_count}",
+                                classes="detail_item",
+                            )
+
+            with Container(id="button_container"):
+                back_prefix = "🔙 " if show_emojis else ""
+                yield Button(f"{back_prefix}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()

{netshow-0.2.0 → netshow-0.2.2}/src/netshow/styles.py

@@ -12,9 +12,9 @@ $fg_1: #cad8d9;
 $red: #fa5750;
 $green: #75b938;
 $yellow: #dbb32d;
-$blue: #4695f7;
+$blue: #2d5b69;
 $magenta: #f275be;
-$cyan: #41c7b9;
+$cyan: #4191a5;
 $orange: #ed8649;
 $violet: #af88eb;
 
@@ -101,7 +101,7 @@ Header {
     color: $fg_1;
     border-bottom: solid $blue;
     text-style: bold;
-    height: 3;
+    height: 2;
 }
 
 Footer {
@@ -141,7 +141,7 @@ Vertical {
 
 /* === EDGE BORDER FIX === */
 #connection_details {
-    border-right: none;
+    border-right: #fff;
 }
 
 #process_info {
@@ -202,6 +202,7 @@ DataTable:focus .datatable--cursor {
     margin: 0;
     padding: 0;
     border: none;
+    width: 100%;
 }
 
 #connection_details, #process_info {
@@ -241,7 +242,6 @@ DataTable:focus .datatable--cursor {
 .detail_item:hover {
     color: $fg_1;
     background: $bg_2;
-    border-left: $br_blue;
 }
 
 /* === BUTTONS === */
@@ -305,9 +305,6 @@ ScrollableContainer {
 }
 
 /* === ACCESSIBILITY === */
-*:focus {
-    outline: thick $blue;
-}
 
 .epic-glow {
     color: $br_blue;

netshow-0.2.2/src/netshow/types_and_constants.py

@@ -0,0 +1,41 @@
+from typing import TypedDict
+
+# Constants
+REFRESH_INTERVAL = 3.0  # seconds
+CONNECTION_COLUMNS = ["pid", "friendly", "proc", "laddr", "raddr", "status"]
+BASIC_KEYBINDINGS = [
+    ("q", "quit", "Quit"),
+    ("ctrl+r", "refresh", "Force Refresh"),
+    ("f", "toggle_filter", "Filter"),
+    ("s", "sort_by_status", "Sort by Status"),
+    ("p", "sort_by_process", "Sort by Process"),
+    ("i", "toggle_interface", "Interface"),
+    ("e", "toggle_emojis", "Emojis"),
+    ("ctrl+c", "quit", "Hard Quit"),
+    ("/", "search", "Search"),
+]
+
+
+class ConnectionData(TypedDict):
+    """Type definition for connection data."""
+
+    pid: str
+    friendly: str
+    proc: str
+    laddr: str
+    raddr: str
+    status: str
+
+
+class NetworkStats(TypedDict):
+    """Type definition for network statistics."""
+
+    total_connections: int
+    established: int
+    listening: int
+    time_wait: int
+    bytes_sent: int
+    bytes_recv: int
+    packets_sent: int
+    packets_recv: int
+    timestamp: float

{netshow-0.2.0 → netshow-0.2.2}/uv.lock

@@ -214,7 +214,7 @@ wheels = [
 
 [[package]]
 name = "netshow"
-version = "0.1.2"
+version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "psutil" },