Add UI benchmark and desktop mode

Author: youngoat911

.gitignore

@@ -35,6 +35,7 @@ data/models/*.pt
 data/traces/*
 !data/traces/.gitkeep
 !data/models/.gitkeep
+ui-overhead-results/
 
 # Logs
 logs/

benchmark_ui_overhead.py

@@ -0,0 +1,197 @@
+"""Measure CogniOS process-tree and system overhead in browser or desktop mode."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import statistics
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import psutil
+
+
+def summarize(samples: list[dict]) -> dict:
+    fields = (
+        "system_cpu_pct", "app_cpu_pct", "app_rss_mb", "app_processes",
+        "memory_available_mb", "swap_used_mb", "disk_read_mb_s",
+        "disk_write_mb_s", "network_recv_mb_s", "network_sent_mb_s",
+    )
+    if not samples:
+        return {key: {"average": 0.0, "peak": 0.0, "minimum": 0.0} for key in fields}
+
+    return {
+        key: {
+            "average": round(statistics.mean(sample[key] for sample in samples), 2),
+            "peak": round(max(sample[key] for sample in samples), 2),
+            "minimum": round(min(sample[key] for sample in samples), 2),
+        }
+        for key in fields
+    }
+
+
+def self_test() -> None:
+    result = summarize([
+        {"system_cpu_pct": 10, "app_cpu_pct": 20, "app_rss_mb": 100, "app_processes": 2,
+         "memory_available_mb": 1000, "swap_used_mb": 0, "disk_read_mb_s": 1,
+         "disk_write_mb_s": 2, "network_recv_mb_s": 3, "network_sent_mb_s": 4},
+        {"system_cpu_pct": 30, "app_cpu_pct": 40, "app_rss_mb": 200, "app_processes": 4,
+         "memory_available_mb": 800, "swap_used_mb": 1, "disk_read_mb_s": 3,
+         "disk_write_mb_s": 4, "network_recv_mb_s": 5, "network_sent_mb_s": 6},
+    ])
+    assert result["system_cpu_pct"] == {"average": 20, "peak": 30, "minimum": 10}
+    assert result["app_rss_mb"] == {"average": 150, "peak": 200, "minimum": 100}
+    assert summarize([])["system_cpu_pct"] == {"average": 0.0, "peak": 0.0, "minimum": 0.0}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--mode", choices=("browser", "desktop"))
+    parser.add_argument("--pid", type=int, help="PID of the CogniOS main.py process")
+    parser.add_argument("--ui-pid", type=int, help="Optional browser PID; include its process tree")
+    parser.add_argument("--duration", type=int, default=60, help="Sample duration in seconds")
+    parser.add_argument("--interval", type=float, default=1, help="Sample interval in seconds")
+    parser.add_argument("--output", type=Path, default=Path("ui-overhead-results"))
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+
+    if args.self_test:
+        self_test()
+        print("Benchmark summary check passed.")
+        return
+    if not args.mode or not args.pid or args.duration < 1 or args.interval <= 0:
+        parser.error("--mode, --pid, positive --duration, and positive --interval are required")
+
+    try:
+        roots = [psutil.Process(args.pid)]
+        if args.ui_pid:
+            roots.append(psutil.Process(args.ui_pid))
+    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess) as exc:
+        parser.error(f"Could not access process PID(s): {exc}")
+    for proc in roots:
+        proc.cpu_percent(None)
+    psutil.cpu_percent(None)
+
+    args.output.mkdir(parents=True, exist_ok=True)
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    stem = f"ui-overhead-{args.mode}-{stamp}"
+    csv_path = args.output / f"{stem}.csv"
+    json_path = args.output / f"{stem}.json"
+    columns = (
+        "timestamp", "elapsed_s", "mode", "system_cpu_pct", "memory_used_mb",
+        "memory_available_mb", "swap_used_mb", "disk_read_mb_s", "disk_write_mb_s",
+        "network_recv_mb_s", "network_sent_mb_s", "app_cpu_pct", "app_rss_mb",
+        "app_processes", "pid", "parent_pid", "process_name", "process_cpu_pct",
+        "process_rss_mb", "threads", "read_mb", "write_mb",
+    )
+    totals = []
+    started_at = datetime.now(timezone.utc)
+    started = time.monotonic()
+    previous_elapsed = 0.0
+    previous_disk = psutil.disk_io_counters()
+    previous_network = psutil.net_io_counters()
+
+    with csv_path.open("w", newline="", encoding="utf-8") as output:
+        writer = csv.DictWriter(output, fieldnames=columns)
+        writer.writeheader()
+        while time.monotonic() - started < args.duration:
+            time.sleep(min(args.interval, max(0, args.duration - (time.monotonic() - started))))
+            now = datetime.now(timezone.utc).isoformat()
+            app_cpu = app_rss = process_count = 0
+            rows = []
+            seen = set()
+
+            for root in roots:
+                try:
+                    processes = [root, *root.children(recursive=True)]
+                except psutil.Error:
+                    processes = []
+                for proc in processes:
+                    if proc.pid in seen:
+                        continue
+                    seen.add(proc.pid)
+                    try:
+                        info = proc.as_dict(attrs=["pid", "ppid", "name", "memory_info", "num_threads"])
+                        cpu = proc.cpu_percent(None)
+                        io = proc.io_counters()
+                        rss = info["memory_info"].rss / (1024 * 1024)
+                        app_cpu += cpu
+                        app_rss += rss
+                        process_count += 1
+                        rows.append({
+                            "pid": proc.pid, "parent_pid": info["ppid"], "process_name": info["name"],
+                            "process_cpu_pct": round(cpu, 2), "process_rss_mb": round(rss, 2),
+                            "threads": info["num_threads"],
+                            "read_mb": round(io.read_bytes / (1024 * 1024), 2) if io else "",
+                            "write_mb": round(io.write_bytes / (1024 * 1024), 2) if io else "",
+                        })
+                    except (psutil.Error, OSError):
+                        continue
+
+            memory = psutil.virtual_memory()
+            system_cpu = psutil.cpu_percent(None)
+            elapsed = time.monotonic() - started
+            interval = max(elapsed - previous_elapsed, 0.001)
+            disk = psutil.disk_io_counters()
+            network = psutil.net_io_counters()
+            disk_read = (
+                max(0, disk.read_bytes - previous_disk.read_bytes) / 1048576 / interval
+                if disk and previous_disk else 0
+            )
+            disk_write = (
+                max(0, disk.write_bytes - previous_disk.write_bytes) / 1048576 / interval
+                if disk and previous_disk else 0
+            )
+            network_recv = (
+                max(0, network.bytes_recv - previous_network.bytes_recv) / 1048576 / interval
+                if network and previous_network else 0
+            )
+            network_sent = (
+                max(0, network.bytes_sent - previous_network.bytes_sent) / 1048576 / interval
+                if network and previous_network else 0
+            )
+            previous_elapsed, previous_disk, previous_network = elapsed, disk, network
+            sample = {
+                "system_cpu_pct": system_cpu,
+                "app_cpu_pct": app_cpu,
+                "app_rss_mb": app_rss,
+                "app_processes": process_count,
+                "memory_available_mb": round(memory.available / (1024 * 1024), 2),
+                "swap_used_mb": round(psutil.swap_memory().used / (1024 * 1024), 2),
+                "disk_read_mb_s": round(disk_read, 3),
+                "disk_write_mb_s": round(disk_write, 3),
+                "network_recv_mb_s": round(network_recv, 3),
+                "network_sent_mb_s": round(network_sent, 3),
+            }
+            totals.append(sample)
+            shared = {
+                "timestamp": now,
+                "elapsed_s": round(elapsed, 2),
+                "mode": args.mode,
+                **sample,
+                "memory_used_mb": round(memory.used / (1024 * 1024), 2),
+            }
+            for row in rows or [{}]:
+                writer.writerow({**shared, **row})
+            output.flush()
+
+    report = {
+        "mode": args.mode,
+        "started_at": started_at.isoformat(),
+        "duration_seconds": round(time.monotonic() - started, 2),
+        "sample_interval_seconds": args.interval,
+        "samples": len(totals),
+        "process_roots": [proc.pid for proc in roots],
+        "summary": summarize(totals),
+        "rss_note": "Process-tree RSS is summed and can double-count shared memory.",
+        "csv": str(csv_path),
+    }
+    json_path.write_text(json.dumps(report, indent=2), encoding="utf-8")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

check_requirements.py

@@ -15,6 +15,7 @@
     "scikit-learn": "sklearn",
     "python-dotenv": "dotenv",
     "streamlit-autorefresh": "streamlit_autorefresh",
+    "pyside6": "PySide6",
     "umap-learn": "umap",
     "google-genai": "google.genai",
     "pyyaml": "yaml",

dashboard/desktop.py

@@ -0,0 +1,23 @@
+"""Native desktop shell for the existing Streamlit dashboard."""
+
+from __future__ import annotations
+
+import sys
+
+from PySide6.QtCore import QUrl
+from PySide6.QtWidgets import QApplication, QMainWindow
+from PySide6.QtWebEngineWidgets import QWebEngineView
+
+
+def run_dashboard(url: str = "http://127.0.0.1:8501") -> int:
+    app = QApplication(sys.argv)
+    window = QMainWindow()
+    window.setWindowTitle("CogniOS - System Observability")
+    window.resize(1440, 900)
+
+    view = QWebEngineView()
+    view.setUrl(QUrl(url))
+    window.setCentralWidget(view)
+    window.show()
+
+    return app.exec()

main.py

@@ -1,8 +1,10 @@
+import argparse
 import os
 import sys
 import subprocess
 import time
 import threading
+import webbrowser
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 if BASE_DIR not in sys.path:
@@ -77,7 +79,7 @@ def _daemon_watchdog(daemon_script, telemetry_log_path, restart_delay=3):
     return process
 
 
-def main():
+def main(ui_mode="desktop"):
     _ensure_environment()
 
     print("\n=======================================================")
@@ -102,7 +104,7 @@ def main():
     # Give the daemon a moment to initialise DB before dashboard connects
     time.sleep(2)
 
-    # 2. Start the Streamlit Dashboard
+    # 2. Start the existing dashboard so localhost and launcher use one UI.
     dashboard_log = open(dashboard_log_path, 'w')
     dashboard_process = subprocess.Popen(
         [sys.executable, "-m", "streamlit", "run", dashboard_script, "--server.headless=true"],
@@ -113,15 +115,21 @@ def main():
 
     print("\n=======================================================")
     print("All systems are running!")
-    print("Dashboard is available at: http://localhost:8501")
+    print(f"Opening dashboard in {ui_mode} mode...")
     print(f" Telemetry logs : tail -f '{telemetry_log_path}'")
     print(f" Dashboard logs : tail -f '{dashboard_log_path}'")
     print("=======================================================\n")
     print("Press Ctrl+C to stop all services.")
 
     try:
-        while True:
-            time.sleep(1)
+        if ui_mode == "browser":
+            if not webbrowser.open("http://127.0.0.1:8501", new=2):
+                raise RuntimeError("Could not open the dashboard in a browser.")
+            while True:
+                time.sleep(1)
+        else:
+            from dashboard.desktop import run_dashboard
+            run_dashboard()
     except KeyboardInterrupt:
         print("\nStopping CogniOS System...")
     finally:
@@ -134,11 +142,7 @@ def main():
             except subprocess.TimeoutExpired:
                 dashboard_process.kill()
 
-        try:
-            dashboard_log.close()
-        except Exception:
-            pass
-
+        dashboard_log.close()
         print("Shutdown complete. Goodbye!")
 
 
@@ -147,6 +151,9 @@ def run_os_doctor():
     flag_anomaly()
 
 if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--ui", choices=("browser", "desktop"), default="desktop")
+    args = parser.parse_args()
     os_doctor_thread = threading.Thread(target=run_os_doctor, daemon=True)
     os_doctor_thread.start()
-    main()
+    main(args.ui)

pyproject.toml

@@ -12,7 +12,8 @@ dependencies = [
     "scikit-learn>=1.4.0",
     "xgboost>=3.4.0",
     "streamlit>=1.61.1",
-    "plotly>=6.9.0",
+    "pyside6>=6.7.0",
     "streamlit-autorefresh>=1.0.1",
+    "plotly>=6.9.0",
     "umap-learn>=0.5.5",
 ]

requirements.txt

@@ -15,6 +15,7 @@ requests>=2.31.0
 python-dotenv>=1.0.0
 
 # Visualization & Dashboard
+PySide6>=6.7.0
 streamlit>=1.35.0
 streamlit-autorefresh>=1.0.1
 plotly>=5.20.0