cyberdash 1.0.1__tar.gz

cyberdash-1.0.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: cyberdash
+Version: 1.0.1
+Summary: A modern hacker-style TUI dashboard for Linux and Termux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: textual
+Requires-Dist: psutil
+Requires-Dist: requests
+
+# cyberdash

cyberdash-1.0.1/README.md

@@ -0,0 +1 @@
+# cyberdash

cyberdash-1.0.1/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cyberdash"
+version = "1.0.1"
+description = "A modern hacker-style TUI dashboard for Linux and Termux"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "textual",
+    "psutil",
+    "requests"
+]
+
+[project.scripts]
+cyberdash = "cyberdash.app:run"

cyberdash-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cyberdash-1.0.1/src/cyberdash/app.py

@@ -0,0 +1,206 @@
+import random, os, socket, asyncio, subprocess
+from collections import deque
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Header, Footer, Static, DataTable, Label, Input, RichLog, Sparkline
+
+# Import Modular Plugins
+from .plugins.base import ResourceBar
+from .plugins.hardware import HardwareMonitor
+from .plugins.network import NetworkTracker
+from .plugins.processes import ProcessEngine
+from .plugins.shell import ShellCore
+
+class OverlordApp(App):
+    ENABLE_COMMAND_PALETTE = False
+    
+    BINDINGS = [
+        ("q", "quit", "Shutdown"),
+        ("r", "refresh_net", "Re-trace IP"),
+        ("l", "clear_logs", "Wipe Logs"),
+        ("h", "help_menu", "Help"),
+        ("s", "status_check", "Status"),
+        ("k", "kill_process", "Kill Selected"),
+    ]
+
+    CSS = """
+    Screen { background: #000; opacity: 0%; }
+    .panel { border: double #004400; background: #050505; padding: 1; transition: border 500ms; }
+    .glow { border: double #00FF00; }
+    #top-stats { height: 7; border: round #333; margin: 1; padding: 1; }
+    ResourceBar { width: 1fr; margin: 0 2; }
+    ProgressBar > .bar--bar { color: #00FF00 !important; background: #111; }
+    ProgressBar > .bar--complete { color: #00FF00 !important; }
+    #label { color: #00FF00; margin-bottom: 0; }
+    #pct-label { width: 6; margin-left: 1; color: #00FF00; }
+    #middle-container { height: 1fr; }
+    #left-col { width: 40%; }
+    #right-col { width: 60%; }
+    DataTable { height: 1fr; background: #050505; color: #00FF00; border: none; }
+    DataTable > .datatable--cursor { background: #00FF00; color: #000; }
+    RichLog { background: #000; border: tall #111; }
+    Input { border: tall #004400; color: #00FF00; height: 3; transition: border 200ms; }
+    Input:focus { border: tall #00FF00; }
+    #osc-header { height: 1; margin-bottom: 0; }
+    #osc-title { width: 1fr; color: #00FF00; }
+    #cpu-temp { width: 12; text-align: right; color: #00FF00; }
+    #cpu-sparkline { color: #00FF00; height: 3; min-height: 3; margin-top: 0; }
+    #net-id { height: 7; margin-bottom: 1; color: #00FF00; }
+    Footer { dock: bottom; height: 1; background: #000; color: #00FF00; margin-top: 1; }
+    Footer > .footer--key { color: #FFF; background: #000; text-style: bold; }
+    Footer > .footer--description { color: #00FF00; background: #000; margin-right: 2; }
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.hw = HardwareMonitor()
+        self.net = NetworkTracker()
+        self.proc = ProcessEngine()
+        self.shell = ShellCore()
+        self.cpu_history = deque([0]*45, maxlen=45)
+        self.app_data_cache, self.dns_name = None, "Detecting..."
+        self.last_net_key = self.net.get_network_state_key()
+        self.HACKER_EVENTS = [
+            "[cyan][*][/] Memory optimized.", "[green][+][/] Sync: [b]COMPLETE[/]",
+            "[red][!][/] Ping blocked.", "[cyan][*][/] Buffer flushed.",
+            "[yellow][!][/] Partition 04: [u]ReadOnly[/]", "[green][+][/] Security: [b]ACTIVE[/]"
+        ]
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            with Horizontal(id="top-stats"):
+                yield ResourceBar("CPU LOAD", id="cpu-bar")
+                yield ResourceBar("RAM USAGE", id="ram-bar")
+                yield ResourceBar("STORAGE", id="disk-bar")
+            with Horizontal(id="middle-container"):
+                with Vertical(id="left-col", classes="panel"):
+                    yield Label("[b][cyan]>_[/] PROCESS ENGINE")
+                    yield DataTable(id="proc-table")
+                    yield Input(placeholder="Root Shell Access...", id="cmd-input")
+                with Vertical(id="right-col", classes="panel"):
+                    with Horizontal(id="osc-header"):
+                        yield Label("[b]CPU OSCILLOSCOPE[/]", id="osc-title")
+                        yield Label("--°C", id="cpu-temp")
+                    yield Sparkline(id="cpu-sparkline")
+                    yield Label("\n[b]NETWORK IDENTITY[/]")
+                    yield Static("[dim]Requesting Satellite Data...[/]", id="net-id")
+                    yield Label("\n[b]KERNEL LOGS[/]")
+                    yield RichLog(id="sys-log", markup=True)
+        yield Footer()
+
+    # --- PROTECTED KILL ACTION ---
+    def action_kill_process(self):
+        table = self.query_one("#proc-table", DataTable)
+        log = self.query_one("#sys-log")
+        try:
+            row_index = table.cursor_row
+            row_data = table.get_row_at(row_index)
+            target_pid = int(row_data[0])
+            target_name = row_data[1]
+            
+            # --- SUICIDE PROTECTION ---
+            my_pid = os.getpid()
+            if target_pid == my_pid:
+                log.write("[bold red][!][/] ACCESS DENIED: Suicide protocol blocked.\n")
+                return
+
+            # Execute Kill
+            self.shell.execute(f"kill -9 {target_pid}")
+            log.write(f"[bold red][!][/] SIGKILL SENT TO: {target_name} ({target_pid})\n")
+        except:
+            log.write("[red][!][/] Selection Error: No target PID found.\n")
+
+    def update_dashboard(self):
+        log = self.query_one("#sys-log")
+        table = self.query_one("#proc-table")
+        current_cursor = table.cursor_row
+        
+        cpu, ram, disk, is_locked, temp = self.hw.get_stats()
+        temp_wid = self.query_one("#cpu-temp")
+        if temp:
+            t_color = "red" if temp > 70 else "yellow" if temp > 45 else "green"
+            temp_wid.update(f"[{t_color}]{temp:.1f}°C[/]")
+        else:
+            temp_wid.update("[red]N/A[/]")
+
+        if is_locked:
+            self.query_one("#cpu-bar").update_bar(0)
+            self.query_one("#cpu-bar").query_one("#pct-label").update("[red]LOCK[/]")
+            cpu_val = cpu 
+        else:
+            self.query_one("#cpu-bar").update_bar(cpu)
+            cpu_val = cpu
+        
+        self.query_one("#ram-bar").update_bar(ram)
+        self.query_one("#disk-bar").update_bar(disk)
+        self.cpu_history.append(cpu_val)
+        self.query_one("#cpu-sparkline").data = list(self.cpu_history)
+        
+        ms = self.net.get_latency()
+        ms_text = f"[bold green]{ms}ms[/]" if ms > 0 else "[red]OFFLINE[/]"
+        if self.app_data_cache:
+            d = self.app_data_cache
+            self.query_one("#net-id").update(f"IP: [y]{d['ip']}[/]\nISP: [y]{d['isp']}[/]\nLOC: [y]{d['loc']}[/]\nDNS: [cyan]{self.dns_name}[/]\nLATENCY: {ms_text}")
+
+        table.clear()
+        for p in self.proc.get_top_processes():
+            table.add_row(str(p['pid']), p['name'][:12], f"{p['memory_percent']:.1f}%")
+        
+        if current_cursor is not None and current_cursor < len(table.rows):
+            table.move_cursor(row=current_cursor)
+
+        if random.random() > 0.8:
+            log.write(random.choice(self.HACKER_EVENTS) + "\n")
+
+    async def on_mount(self):
+        self.screen.styles.animate("opacity", value=1.0, duration=1.0)
+        self.set_interval(1.5, self.pulse_borders)
+        table = self.query_one("#proc-table")
+        table.add_columns("PID", "NAME", "MEM%")
+        table.cursor_type = "row"
+        self.set_interval(2.0, self.update_dashboard)
+        self.run_worker(self.fetch_network_info, thread=True)
+
+    async def fetch_network_info(self):
+        data, dns = self.net.trace_identity(), self.net.get_dns_provider()
+        if data:
+            self.app_data_cache, self.dns_name = data, dns
+            self.query_one("#net-id").update(f"IP: [y]{data['ip']}[/]\nISP: [y]{data['isp']}[/]\nDNS: [cyan]{dns}[/]")
+
+    async def on_input_submitted(self, event: Input.Submitted):
+        cmd = event.value.strip()
+        if not cmd: return
+        log = self.query_one("#sys-log")
+        event.input.value = ""
+        if cmd.lower() in ["clear", "cls"]:
+            log.clear()
+            return
+        log.write(f"[bold cyan]#[/] {cmd}\n")
+        self.run_worker(lambda: self.shell_worker(cmd), thread=True)
+
+    def shell_worker(self, cmd):
+        output = self.shell.execute(cmd)
+        self.call_from_thread(self.display_output, output)
+
+    def display_output(self, output):
+        log = self.query_one("#sys-log")
+        if output:
+            for line in output.splitlines()[-8:]: log.write(f"  [dim]{line}[/]\n")
+        log.scroll_end()
+
+    def pulse_borders(self):
+        for panel in self.query(".panel"): panel.toggle_class("glow")
+    def action_refresh_net(self): self.run_worker(self.fetch_network_info, thread=True)
+    def action_clear_logs(self): self.query_one("#sys-log").clear()
+    def action_help_menu(self): self.query_one("#sys-log").write("[bold yellow]=== COMMAND GUIDE ===[/]\n")
+    def action_status_check(self):
+        uptime = self.shell.execute("uptime -p")
+        self.query_one("#sys-log").write(f"[cyan][*][/] [white]Uptime:[/] {uptime.strip()}\n")
+
+def run():
+    app = OverlordApp()
+    app.run()
+
+if __name__ == "__main__":
+    run()

cyberdash-1.0.1/src/cyberdash/m.py

@@ -0,0 +1,252 @@
+import random
+import os
+import socket
+import asyncio
+from collections import deque
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Header, Footer, Static, DataTable, Label, Input, RichLog, Sparkline
+
+# Import Modular Plugins
+from plugins.base import ResourceBar
+from plugins.hardware import HardwareMonitor
+from plugins.network import NetworkTracker
+from plugins.processes import ProcessEngine
+from plugins.shell import ShellCore
+
+class OverlordApp(App):
+    ENABLE_COMMAND_PALETTE = False
+    
+    # User Bindings
+    BINDINGS = [
+        ("q", "quit", "Shutdown"),
+        ("r", "refresh_net", "Re-trace IP"),
+        ("l", "clear_logs", "Wipe Logs"),
+        ("h", "help_menu", "Help"),
+        ("s", "status_check", "Status"),
+    ]
+
+    # Optimized Stealth CSS
+    CSS = """
+    Screen { background: #000; }
+    .panel { border: double #00FF00; background: #050505; padding: 1; }
+    
+    #top-stats { height: 7; border: round #333; margin: 1; padding: 1; }
+    ResourceBar { width: 1fr; margin: 0 2; }
+    
+    ProgressBar > .bar--bar { color: #00FF00 !important; background: #111; }
+    ProgressBar > .bar--complete { color: #00FF00 !important; }
+    
+    #label { color: #00FF00; margin-bottom: 0; }
+    #pct-label { width: 6; margin-left: 1; color: #00FF00; }
+    
+    #middle-container { height: 1fr; }
+    #left-col { width: 40%; }
+    #right-col { width: 60%; }
+    
+    DataTable { height: 1fr; background: #050505; color: #00FF00; border: none; }
+    RichLog { background: #000; border: tall #111; }
+    
+    Input { border: tall #00FF00; color: #00FF00; height: 3; }
+    Sparkline { color: #00FF00; height: 3; }
+    
+    #net-id { height: 7; margin-bottom: 1; color: #00FF00; }
+    
+    Footer { dock: bottom; height: 1; background: #000; color: #00FF00; margin-top: 1; }
+    Footer > .footer--key { color: #FFF; background: #000; }
+    Footer > .footer--description { color: #00FF00; background: #000; margin-right: 2; }
+    """
+
+    def __init__(self):
+        super().__init__()
+        # Initialize Logic Plugins
+        self.hw = HardwareMonitor()
+        self.net = NetworkTracker()
+        self.proc = ProcessEngine()
+        self.shell = ShellCore()
+        
+        # UI & Data State
+        self.cpu_history = deque([0]*40, maxlen=40)
+        self.app_data_cache = None
+        self.dns_name = "Detecting..."
+        self.last_net_key = self.net.get_network_state_key()
+        
+        # System Event Templates
+        self.HACKER_EVENTS = [
+            "[cyan][*][/] Memory clusters optimized.",
+            "[green][+][/] Background sync: [bold white]COMPLETE[/]",
+            "[red][!][/] Unauthorized ping blocked.",
+            "[cyan][*][/] Kernel buffer flushed.",
+            "[yellow][!][/] Partition 04: [u]Read-only[/]",
+            "[green][+][/] Security protocol: [bold green]ACTIVE[/]",
+            "[dim][*] Signal telemetry recalibrated.[/]"
+        ]
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            # Hardware Status Bar
+            with Horizontal(id="top-stats"):
+                yield ResourceBar("CPU LOAD", id="cpu-bar")
+                yield ResourceBar("RAM USAGE", id="ram-bar")
+                yield ResourceBar("STORAGE", id="disk-bar")
+            
+            # Interactive Core
+            with Horizontal(id="middle-container"):
+                # Shell & Process Side
+                with Vertical(id="left-col", classes="panel"):
+                    yield Label("[b][cyan]>_[/] PROCESS ENGINE")
+                    yield DataTable(id="proc-table")
+                    yield Input(placeholder="Root Shell Access...", id="cmd-input")
+                
+                # Diagnostics & Log Side
+                with Vertical(id="right-col", classes="panel"):
+                    yield Label("[b]CPU OSCILLOSCOPE[/]")
+                    yield Sparkline(id="cpu-sparkline")
+                    
+                    yield Label("\n[b]NETWORK IDENTITY[/]")
+                    yield Static("[dim]Requesting Satellite Data...[/]", id="net-id")
+                    
+                    yield Label("\n[b]KERNEL LOGS[/]")
+                    yield RichLog(id="sys-log", markup=True)
+        yield Footer()
+
+    # --- ACTIONS (Keyboard Shortcuts) ---
+
+    def action_help_menu(self):
+        log = self.query_one("#sys-log")
+        log.write("\n[bold yellow]=== COMMAND GUIDE ===[/]\n")
+        log.write("[white]Q[/]: Shutdown | [white]R[/]: IP Trace | [white]L[/]: Wipe Logs\n")
+        log.write("[white]H[/]: Help | [white]S[/]: Diagnostics\n")
+        log.write("[dim]Terminal: 'clear' to wipe, 'help' for guide.[/]\n")
+
+    def action_status_check(self):
+        log = self.query_one("#sys-log")
+        log.write("\n[bold green]>>> INITIATING DIAGNOSTICS...[/]\n")
+        uptime = self.shell.execute("uptime -p")
+        log.write(f"[cyan][*][/] [white]Uptime:[/] {uptime.strip()}\n")
+        log.write(f"[cyan][*][/] [white]DNS Service:[/] {self.dns_name}\n")
+        log.write("[bold green]>>> DIAGNOSTICS COMPLETE.[/]\n")
+
+    def action_refresh_net(self):
+        self.query_one("#net-id").update("[dim]Re-tracing...[/]")
+        self.run_worker(self.fetch_network_info, thread=True)
+
+    def action_clear_logs(self):
+        self.query_one("#sys-log").clear()
+
+    # --- CORE WORKERS & UPDATERS ---
+
+    def on_mount(self):
+        log = self.query_one("#sys-log")
+        self.query_one("#proc-table").add_columns("PID", "NAME", "MEM%")
+        
+        # Initial Boot UI
+        log.write("[yellow][!][/] KERNEL BOOT SEQUENCE INITIATED...\n")
+        log.write("[cyan][*][/] MODULE: HardwareMonitor... [green]LOADED[/]\n")
+        log.write("[cyan][*][/] MODULE: NetworkTracker... [green]LOADED[/]\n")
+        log.write("[white][!][/] SYSTEM OVERLORD [bold green]ONLINE[/].\n")
+        
+        # Start intervals
+        self.set_interval(2.0, self.update_dashboard)
+        self.run_worker(self.fetch_network_info, thread=True)
+
+    async def fetch_network_info(self):
+        """Fetch heavy network data (IP/ISP/DNS) in background."""
+        data = self.net.trace_identity()
+        dns = self.net.get_dns_provider()
+        if data:
+            self.app_data_cache = data
+            self.dns_name = dns
+            val = f"IP: [y]{data['ip']}[/]\nISP: [y]{data['isp']}[/]\nDNS: [cyan]{dns}[/]"
+            self.query_one("#net-id").update(val)
+
+    def update_dashboard(self):
+        """Main refresh loop for hardware and live latency."""
+        log = self.query_one("#sys-log")
+        
+        # 1. AUTO-REFRESH NETWORK ON CONNECTIVITY CHANGE
+        current_net_key = self.net.get_network_state_key()
+        if current_net_key != self.last_net_key:
+            self.last_net_key = current_net_key
+            log.write("[yellow][!][/] Network change detected. Re-tracing...\n")
+            self.run_worker(self.fetch_network_info, thread=True)
+
+        # 2. Hardware Resource Update
+        cpu, ram, disk = self.hw.get_stats()
+        if cpu == -1.0:
+            self.query_one("#cpu-bar").update_bar(0)
+            self.query_one("#cpu-bar").query_one("#pct-label").update("[red]LOCK[/]")
+            cpu_val = 0
+        else:
+            self.query_one("#cpu-bar").update_bar(cpu)
+            cpu_val = cpu
+        
+        self.query_one("#ram-bar").update_bar(ram)
+        self.query_one("#disk-bar").update_bar(disk)
+        
+        # Sparkline update
+        self.cpu_history.append(cpu_val)
+        self.query_one("#cpu-sparkline").data = list(self.cpu_history)
+        
+        # 3. Network Latency Update (LIVE)
+        ms = self.net.get_latency()
+        latency_color = "green" if ms < 100 else "yellow" if ms < 300 else "red"
+        ms_text = f"[bold {latency_color}]{ms}ms[/]" if ms > 0 else "[red]OFFLINE[/]"
+        
+        if self.app_data_cache:
+            d = self.app_data_cache
+            self.query_one("#net-id").update(
+                f"IP: [y]{d['ip']}[/]\nISP: [y]{d['isp']}[/]\n"
+                f"LOC: [y]{d['loc']}[/]\nDNS: [cyan]{self.dns_name}[/]\n"
+                f"LATENCY: {ms_text}"
+            )
+        elif ms == -1:
+             self.query_one("#net-id").update("[red]NO INTERNET CONNECTION[/]")
+
+        # 4. Process Table Update
+        table = self.query_one("#proc-table")
+        table.clear()
+        for p in self.proc.get_top_processes():
+            table.add_row(str(p['pid']), p['name'][:12], f"{p['memory_percent']:.1f}%")
+
+        # 5. Background Activity Logs
+        if random.random() > 0.8:
+            log.write(random.choice(self.HACKER_EVENTS) + "\n")
+
+    async def on_input_submitted(self, event: Input.Submitted):
+        cmd = event.value.strip()
+        log = self.query_one("#sys-log")
+        event.input.value = ""
+
+        if not cmd: return
+
+        if cmd.lower() in ["clear", "cls"]:
+            log.clear()
+            return
+        
+        if cmd.lower() == "help":
+            self.action_help_menu()
+            return
+
+        # NEW: Run the shell command in a background worker
+        log.write(f"[bold cyan]#[/] {cmd}\n")
+        
+        # We define a small internal function to run the command
+        def run_shell():
+            output = self.shell.execute(cmd)
+            # Use call_from_thread to safely update the UI from the worker
+            self.call_from_thread(self.post_shell_output, output)
+
+        self.run_worker(run_shell, thread=True)
+
+    def post_shell_output(self, output: str):
+        """Callback to print the result once the background task finishes."""
+        log = self.query_one("#sys-log")
+        if output:
+            for line in output.splitlines()[-15:]: # Increased to 15 lines
+                log.write(f"  [dim]{line}[/]\n")
+        log.scroll_end()
+
+if __name__ == "__main__":
+    OverlordApp().run()

cyberdash-1.0.1/src/cyberdash/plugins/base.py

@@ -0,0 +1,23 @@
+from textual.widgets import Static, Label, ProgressBar
+from textual.containers import Horizontal
+
+class ResourceBar(Static):
+    def __init__(self, name: str, **kwargs):
+        super().__init__(**kwargs)
+        self.resource_name = name
+
+    def compose(self):
+        yield Label(f"[b]{self.resource_name}[/]", id="label")
+        with Horizontal():
+            yield ProgressBar(total=100, show_eta=False, show_percentage=False, id="bar")
+            yield Label("0%", id="pct-label")
+
+    def update_bar(self, value: float):
+        try:
+            bar = self.query_one("#bar", ProgressBar)
+            # FIX: Animate the 'progress' attribute of the bar widget directly
+            bar.animate("progress", value=float(value), duration=0.5)
+            # Update the text label
+            self.query_one("#pct-label").update(f"{int(value)}%")
+        except:
+            pass

cyberdash-1.0.1/src/cyberdash/plugins/hardware.py

@@ -0,0 +1,65 @@
+import psutil, shutil, os, random, subprocess, json
+# At the top:
+from .base import ResourceBar
+
+class HardwareMonitor:
+    def __init__(self):
+        try:
+            psutil.cpu_percent(interval=None)
+        except:
+            pass
+
+    def get_cpu_temp(self):
+        """Tries 3 methods to get temperature: Real, Battery, or Estimated."""
+        # --- Method 1: Real Hardware Sensors (SysFS) ---
+        for i in range(15):
+            path = f"/sys/class/thermal/thermal_zone{i}/temp"
+            try:
+                if os.path.exists(path):
+                    with open(path, "r") as f:
+                        t = int(f.read().strip())
+                        if t > 1000: t /= 1000
+                        if 25 < t < 95: return t
+            except: continue
+
+        # --- Method 2: Termux-API (Battery Temp Proxy) ---
+        try:
+            # This calls the termux-api command
+            res = subprocess.check_output(["termux-battery-status"], timeout=1)
+            data = json.loads(res)
+            return data.get("temperature") # Returns float like 38.5
+        except:
+            pass
+
+        # --- Method 3: Thermal Proxy (Simulated based on Load) ---
+        # If we can't read anything, we simulate 'System Warmth' 
+        # based on current CPU usage to keep the dashboard 'alive'.
+        try:
+            load = psutil.cpu_percent()
+            # Base temp 32C + (Load * 0.2) + random fluctuation
+            estimate = 32 + (load * 0.15) + random.uniform(-1, 1)
+            return estimate
+        except:
+            return random.uniform(35, 42)
+
+    def get_stats(self):
+        try:
+            cpu = psutil.cpu_percent(interval=0.1)
+            is_locked = False
+        except PermissionError:
+            cpu = random.uniform(1.0, 5.0) 
+            is_locked = True
+        
+        try:
+            ram = psutil.virtual_memory().percent
+        except:
+            ram = 0.0
+            
+        try:
+            usage = shutil.disk_usage(os.path.expanduser("~"))
+            disk = (usage.used / usage.total) * 100
+        except:
+            disk = 0.0
+            
+        temp = self.get_cpu_temp()
+        return cpu, ram, disk, is_locked, temp

cyberdash-1.0.1/src/cyberdash/plugins/n.py

@@ -0,0 +1,59 @@
+import requests
+
+class NetworkTracker:
+    def trace_identity(self):
+        headers = {"User-Agent": "TermuxCyberDash/1.2"}
+        # List of URLs to try
+        urls = ["https://ipapi.co/json/", "http://ip-api.com/json/"]
+        
+        for url in urls:
+            try:
+                # Short 3-second timeout to prevent UI hanging
+                res = requests.get(url, headers=headers, timeout=3).json()
+                if res:
+                    return {
+                        "ip": res.get('ip') or res.get('query'),
+                        "isp": res.get('org') or res.get('isp'),
+                        "loc": f"{res.get('city')}, {res.get('country_name') or res.get('country')}"
+                    }
+            except:
+                continue
+        return None
+   
+    def get_latency(self):
+        """Measure latency (ms) to Cloudflare DNS."""
+        target = "1.1.1.1"
+        try:
+            start = time.time()
+            # Try a TCP connection to port 53 (DNS)
+            socket.create_connection((target, 53), timeout=2)
+            end = time.time()
+            return int((end - start) * 1000)
+        except:
+            return -1
+
+    def get_dns_provider(self):
+        """Identify current DNS provider."""
+        try:
+            # On Termux/Android, we check getprop
+            dns_ip = subprocess.getoutput("getprop net.dns1").strip()
+            if not dns_ip:
+                # Fallback for standard Linux
+                with open("/etc/resolv.conf", "r") as f:
+                    for line in f:
+                        if line.startswith("nameserver"):
+                            dns_ip = line.split()[1]
+                            break
+            
+            # Map common IPs to names
+            mapping = {
+                "1.1.1.1": "Cloudflare",
+                "1.0.0.1": "Cloudflare",
+                "8.8.8.8": "Google Public DNS",
+                "8.8.4.4": "Google Public DNS",
+                "9.9.9.9": "Quad9",
+                "208.67.222.222": "OpenDNS"
+            }
+            return mapping.get(dns_ip, dns_ip if dns_ip else "System Default")
+        except:
+            return "Internal/Protected"

cyberdash-1.0.1/src/cyberdash/plugins/network.py

@@ -0,0 +1,80 @@
+import requests
+import socket
+import time
+import subprocess
+import psutil
+
+class NetworkTracker:
+    def trace_identity(self):
+        """Fetch ISP/IP info."""
+        headers = {"User-Agent": "TermuxCyberDash/1.2"}
+        try:
+            res = requests.get("https://ipapi.co/json/", headers=headers, timeout=5).json()
+            if res and not res.get("error"):
+                return {
+                    "ip": res.get('ip') or res.get('query'),
+                    "isp": res.get('org') or res.get('isp'),
+                    "loc": f"{res.get('city')}, {res.get('country_name') or res.get('country')}"
+                }
+        except:
+            pass
+        return None
+
+    def get_network_state_key(self):
+        """
+        Creates a fingerprint of the network.
+        Now watches local IPs AND System DNS properties.
+        """
+        key = ""
+        try:
+            # 1. Watch Local IP changes (Wi-Fi vs Data)
+            interfaces = psutil.net_if_addrs()
+            for snic in interfaces:
+                for addr in interfaces[snic]:
+                    key += str(addr.address)
+            
+            # 2. Watch Android DNS properties
+            # If you switch Private DNS, these properties often change
+            key += subprocess.getoutput("getprop net.dns1")
+            key += subprocess.getoutput("getprop net.dns2")
+            
+            return key
+        except:
+            return key
+
+    def get_latency(self):
+        """Measure latency (ms)."""
+        targets = [("1.1.1.1", 53), ("8.8.8.8", 53), ("google.com", 80)]
+        for host, port in targets:
+            try:
+                start = time.time()
+                socket.create_connection((host, port), timeout=2)
+                end = time.time()
+                return int((end - start) * 1000)
+            except:
+                continue
+        return -1
+
+    def get_dns_provider(self):
+        """Identifies the DNS provider handling your traffic."""
+        try:
+            # Check Cloudflare's diagnostic trace (Very fast)
+            trace = requests.get("https://1.1.1.1/cdn-cgi/trace", timeout=2).text
+            if "dns=on" in trace: return "Cloudflare (1.1.1.1)"
+            if "warp=on" in trace: return "Cloudflare WARP"
+        except:
+            pass
+
+        try:
+            # Server-side DNS leak probe
+            res = requests.get("http://edns.ip-api.com/json", timeout=2).json()
+            dns_data = res.get("dns", {})
+            geo = dns_data.get("geo", "")
+            if "Cloudflare" in geo: return "Cloudflare DNS"
+            if "Google" in geo: return "Google DNS"
+            if "OpenDNS" in geo: return "OpenDNS"
+            
+            ip = dns_data.get("ip", "")
+            return f"Resolver ({ip[:15]})" if ip else "ISP Default"
+        except:
+            return "ISP / Private DNS"

cyberdash-1.0.1/src/cyberdash/plugins/processes.py

@@ -0,0 +1,12 @@
+import psutil
+
+class ProcessEngine:
+    def get_top_processes(self, limit=8):
+        procs = []
+        for p in psutil.process_iter(['pid', 'name', 'memory_percent']):
+            try:
+                if p.info['name'] and p.info['memory_percent'] is not None:
+                    procs.append(p.info)
+            except (psutil.AccessDenied, psutil.NoSuchProcess):
+                continue
+        return sorted(procs, key=lambda x: x['memory_percent'], reverse=True)[:limit]

cyberdash-1.0.1/src/cyberdash/plugins/shell.py

@@ -0,0 +1,18 @@
+import subprocess
+
+class ShellCore:
+    def execute(self, cmd: str):
+        try:
+            # Increased timeout to 300 seconds (5 minutes) for big tasks like 'pkg up'
+            result = subprocess.run(
+                cmd, 
+                shell=True, 
+                capture_output=True, 
+                text=True, 
+                timeout=300 
+            )
+            return result.stdout if result.stdout else result.stderr
+        except subprocess.TimeoutExpired:
+            return "Error: Command timed out. Task is too large for dashboard shell."
+        except Exception as e:
+            return f"Error: {str(e)}"

cyberdash-1.0.1/src/cyberdash.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: cyberdash
+Version: 1.0.1
+Summary: A modern hacker-style TUI dashboard for Linux and Termux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: textual
+Requires-Dist: psutil
+Requires-Dist: requests
+
+# cyberdash

cyberdash-1.0.1/src/cyberdash.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/cyberdash/app.py
+src/cyberdash/m.py
+src/cyberdash.egg-info/PKG-INFO
+src/cyberdash.egg-info/SOURCES.txt
+src/cyberdash.egg-info/dependency_links.txt
+src/cyberdash.egg-info/entry_points.txt
+src/cyberdash.egg-info/requires.txt
+src/cyberdash.egg-info/top_level.txt
+src/cyberdash/plugins/__init__.py
+src/cyberdash/plugins/base.py
+src/cyberdash/plugins/hardware.py
+src/cyberdash/plugins/n.py
+src/cyberdash/plugins/network.py
+src/cyberdash/plugins/processes.py
+src/cyberdash/plugins/shell.py

cyberdash-1.0.1/src/cyberdash.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cyberdash-1.0.1/src/cyberdash.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cyberdash = cyberdash.app:run

cyberdash-1.0.1/src/cyberdash.egg-info/requires.txt

@@ -0,0 +1,3 @@
+textual
+psutil
+requests

cyberdash-1.0.1/src/cyberdash.egg-info/top_level.txt

@@ -0,0 +1 @@
+cyberdash