Merge pull request #26 from bunny-lab-io/codex/add-device_details-page-with-placeholder-data

Add device details page with tabbed placeholder data

.gitignore

@@ -17,7 +17,7 @@ Borealis-Server.exe
 /ElectronApp/
 
 # Misc Files/Folders
-.vs/s
+.vs/
 /Update_Staging/
 /Macro_Testing/
 
@@ -26,3 +26,6 @@ Borealis-Server.exe
 /Dependencies/Python/
 /Dependencies/AutoHotKey/
 /Data/Server/Python_API_Endpoints/Tesseract-OCR/
+
+# Deployed Environment Folders
+/Devices/

Data/Agent/borealis-agent.py

@@ -14,6 +14,15 @@ import random  # Macro Randomization
 import platform  # OS Detection
 import importlib.util
 import time  # Heartbeat timestamps
+import subprocess
+import getpass
+
+import requests
+try:
+    import psutil
+except Exception:
+    psutil = None
+import aiohttp
 
 import socketio
 from qasync import QEventLoop
@@ -205,6 +214,195 @@ async def send_heartbeat():
             print(f"[WARN] heartbeat emit failed: {e}")
         await asyncio.sleep(5)
 
+# ---------------- Detailed Agent Data ----------------
+
+def _get_internal_ip():
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except Exception:
+        return "unknown"
+
+def collect_summary():
+    try:
+        last_user = getpass.getuser()
+    except Exception:
+        last_user = "unknown"
+    try:
+        last_reboot = "unknown"
+        if psutil:
+            last_reboot = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(psutil.boot_time()))
+    except Exception:
+        last_reboot = "unknown"
+
+    created = CONFIG.data.get("created")
+    if not created:
+        created = time.strftime("%Y-%m-%d %H:%M:%S")
+        CONFIG.data["created"] = created
+        CONFIG._write()
+
+    try:
+        external_ip = requests.get("https://api.ipify.org", timeout=5).text.strip()
+    except Exception:
+        external_ip = "unknown"
+
+    return {
+        "hostname": socket.gethostname(),
+        "operating_system": CONFIG.data.get("agent_operating_system", detect_agent_os()),
+        "last_user": last_user,
+        "internal_ip": _get_internal_ip(),
+        "external_ip": external_ip,
+        "last_reboot": last_reboot,
+        "created": created,
+    }
+
+def collect_software():
+    items = []
+    plat = platform.system().lower()
+    try:
+        if plat == "windows":
+            out = subprocess.run(["wmic", "product", "get", "name,version"], capture_output=True, text=True, timeout=60)
+            for line in out.stdout.splitlines():
+                if line.strip() and not line.lower().startswith("name"):
+                    parts = line.strip().split("  ")
+                    name = parts[0].strip()
+                    version = parts[-1].strip() if len(parts) > 1 else ""
+                    if name:
+                        items.append({"name": name, "version": version})
+        elif plat == "linux":
+            out = subprocess.run(["dpkg-query", "-W", "-f=${Package}\t${Version}\n"], capture_output=True, text=True)
+            for line in out.stdout.splitlines():
+                if "\t" in line:
+                    name, version = line.split("\t", 1)
+                    items.append({"name": name, "version": version})
+        else:
+            out = subprocess.run([sys.executable, "-m", "pip", "list", "--format", "json"], capture_output=True, text=True)
+            data = json.loads(out.stdout or "[]")
+            for pkg in data:
+                items.append({"name": pkg.get("name"), "version": pkg.get("version")})
+    except Exception as e:
+        print(f"[WARN] collect_software failed: {e}")
+    return items[:100]
+
+def collect_memory():
+    entries = []
+    plat = platform.system().lower()
+    try:
+        if plat == "windows":
+            out = subprocess.run([
+                "wmic",
+                "memorychip",
+                "get",
+                "BankLabel,Speed,SerialNumber,Capacity"
+            ], capture_output=True, text=True)
+            lines = [l for l in out.stdout.splitlines() if l.strip() and "BankLabel" not in l]
+            for line in lines:
+                parts = [p for p in line.split() if p]
+                if len(parts) >= 4:
+                    entries.append({
+                        "slot": parts[0],
+                        "speed": parts[1],
+                        "serial": parts[2],
+                        "capacity": parts[3],
+                    })
+        elif plat == "linux":
+            out = subprocess.run(["dmidecode", "-t", "17"], capture_output=True, text=True)
+            slot = speed = serial = capacity = None
+            for line in out.stdout.splitlines():
+                line = line.strip()
+                if line.startswith("Locator:"):
+                    slot = line.split(":", 1)[1].strip()
+                elif line.startswith("Speed:"):
+                    speed = line.split(":", 1)[1].strip()
+                elif line.startswith("Serial Number:"):
+                    serial = line.split(":", 1)[1].strip()
+                elif line.startswith("Size:"):
+                    capacity = line.split(":", 1)[1].strip()
+                elif not line and slot:
+                    entries.append({
+                        "slot": slot,
+                        "speed": speed or "unknown",
+                        "serial": serial or "unknown",
+                        "capacity": capacity or "unknown",
+                    })
+                    slot = speed = serial = capacity = None
+            if slot:
+                entries.append({
+                    "slot": slot,
+                    "speed": speed or "unknown",
+                    "serial": serial or "unknown",
+                    "capacity": capacity or "unknown",
+                })
+    except Exception as e:
+        print(f"[WARN] collect_memory failed: {e}")
+
+    if not entries:
+        try:
+            if psutil:
+                vm = psutil.virtual_memory()
+                entries.append({
+                    "slot": "physical",
+                    "speed": "unknown",
+                    "serial": "unknown",
+                    "capacity": vm.total,
+                })
+        except Exception:
+            pass
+    return entries
+
+def collect_storage():
+    disks = []
+    try:
+        if psutil:
+            for part in psutil.disk_partitions():
+                try:
+                    usage = psutil.disk_usage(part.mountpoint)
+                except Exception:
+                    continue
+                disks.append({
+                    "drive": part.device,
+                    "disk_type": "Removable" if "removable" in part.opts.lower() else "Fixed Disk",
+                    "usage": usage.percent,
+                    "total": usage.total,
+                    "free": 100 - usage.percent,
+                })
+    except Exception as e:
+        print(f"[WARN] collect_storage failed: {e}")
+    return disks
+
+def collect_network():
+    adapters = []
+    try:
+        if psutil:
+            for name, addrs in psutil.net_if_addrs().items():
+                ips = [a.address for a in addrs if getattr(a, "family", None) == socket.AF_INET]
+                mac = next((a.address for a in addrs if getattr(a, "family", None) == getattr(psutil, "AF_LINK", object)), "unknown")
+                adapters.append({"adapter": name, "ips": ips, "mac": mac})
+    except Exception as e:
+        print(f"[WARN] collect_network failed: {e}")
+    return adapters
+
+async def send_agent_details():
+    """Collect detailed agent data and send to server periodically."""
+    while True:
+        try:
+            details = {
+                "summary": collect_summary(),
+                "software": collect_software(),
+                "memory": collect_memory(),
+                "storage": collect_storage(),
+                "network": collect_network(),
+            }
+            url = CONFIG.data.get("borealis_server_url", "http://localhost:5000") + "/api/agent/details"
+            async with aiohttp.ClientSession() as session:
+                await session.post(url, json={"agent_id": AGENT_ID, "details": details}, timeout=10)
+        except Exception as e:
+            print(f"[WARN] Failed to send agent details: {e}")
+        await asyncio.sleep(300)
+
 @sio.event
 async def connect():
     print(f"[WebSocket] Connected to Borealis Server with Agent ID: {AGENT_ID}")
@@ -593,6 +791,7 @@ if __name__=='__main__':
         background_tasks.append(loop.create_task(idle_task()))
         # Start periodic heartbeats
         background_tasks.append(loop.create_task(send_heartbeat()))
+        background_tasks.append(loop.create_task(send_agent_details()))
         loop.run_forever()
     except Exception as e:
         print(f"[FATAL] Event loop crashed: {e}")

Data/Server/WebUI/src/App.jsx

@@ -29,6 +29,7 @@ import DeviceList from "./Device_List";
 import ScriptList from "./Script_List";
 import ScheduledJobsList from "./Scheduled_Jobs_List";
 import Login from "./Login.jsx";
+import DeviceDetails from "./Device_Details";
 
 import { io } from "socket.io-client";
 
@@ -77,6 +78,7 @@ export default function App() {
   const [tabs, setTabs] = useState([{ id: "flow_1", tab_name: "Flow 1", nodes: [], edges: [] }]);
   const [activeTabId, setActiveTabId] = useState("flow_1");
   const [currentPage, setCurrentPage] = useState("devices");
+  const [selectedDevice, setSelectedDevice] = useState(null);
 
   const [aboutAnchorEl, setAboutAnchorEl] = useState(null);
   const [creditsDialogOpen, setCreditsDialogOpen] = useState(false);
@@ -288,7 +290,25 @@ export default function App() {
   const renderMainContent = () => {
     switch (currentPage) {
       case "devices":
-        return <DeviceList />;
+        return (
+          <DeviceList
+            onSelectDevice={(d) => {
+              setSelectedDevice(d);
+              setCurrentPage("device_details");
+            }}
+          />
+        );
+
+      case "device_details":
+        return (
+          <DeviceDetails
+            device={selectedDevice}
+            onBack={() => {
+              setCurrentPage("devices");
+              setSelectedDevice(null);
+            }}
+          />
+        );
 
       case "jobs":
         return <ScheduledJobsList />;

Data/Server/WebUI/src/Device_Details.jsx

@@ -0,0 +1,259 @@
+////////// PROJECT FILE SEPARATION LINE ////////// CODE AFTER THIS LINE ARE FROM: <ProjectRoot>/Data/WebUI/src/Device_Details.jsx
+
+import React, { useState, useEffect } from "react";
+import {
+  Paper,
+  Box,
+  Tabs,
+  Tab,
+  Typography,
+  Table,
+  TableHead,
+  TableRow,
+  TableCell,
+  TableBody,
+  Button
+} from "@mui/material";
+
+export default function DeviceDetails({ device, onBack }) {
+  const [tab, setTab] = useState(0);
+  const [agent, setAgent] = useState(device || {});
+  const [details, setDetails] = useState({});
+
+  useEffect(() => {
+    if (!device || !device.id) return;
+    const load = async () => {
+      try {
+        const [agentsRes, detailsRes] = await Promise.all([
+          fetch("/api/agents"),
+          fetch(`/api/agent/details/${device.id}`)
+        ]);
+        const agentsData = await agentsRes.json();
+        if (agentsData && agentsData[device.id]) {
+          setAgent({ id: device.id, ...agentsData[device.id] });
+        }
+        const detailData = await detailsRes.json();
+        setDetails(detailData || {});
+      } catch (e) {
+        console.warn("Failed to load device info", e);
+      }
+    };
+    load();
+  }, [device]);
+
+  const formatBytes = (val) => {
+    if (val === undefined || val === null || val === "unknown") return "unknown";
+    let num = Number(val);
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let i = 0;
+    while (num >= 1024 && i < units.length - 1) {
+      num /= 1024;
+      i++;
+    }
+    return `${num.toFixed(1)} ${units[i]}`;
+  };
+
+  const summary = details.summary || {};
+  const summaryItems = [
+    { label: "Device Name", value: summary.hostname || agent.hostname || device?.hostname || "unknown" },
+    { label: "Description", value: summary.description || "unknown" },
+    { label: "Operating System", value: summary.operating_system || agent.agent_operating_system || "unknown" },
+    { label: "Last User", value: summary.last_user || "unknown" },
+    { label: "Internal IP", value: summary.internal_ip || "unknown" },
+    { label: "External IP", value: summary.external_ip || "unknown" },
+    { label: "Last Reboot", value: summary.last_reboot || "unknown" },
+    { label: "Created", value: summary.created || "unknown" }
+  ];
+
+  const renderSummary = () => (
+    <Table size="small">
+      <TableBody>
+        {summaryItems.map((item) => (
+          <TableRow key={item.label}>
+            <TableCell sx={{ fontWeight: 500 }}>{item.label}</TableCell>
+            <TableCell>{item.value}</TableCell>
+          </TableRow>
+        ))}
+      </TableBody>
+    </Table>
+  );
+
+  const placeholderTable = (headers) => (
+    <Table size="small">
+      <TableHead>
+        <TableRow>
+          {headers.map((h) => (
+            <TableCell key={h}>{h}</TableCell>
+          ))}
+        </TableRow>
+      </TableHead>
+      <TableBody>
+        <TableRow>
+          <TableCell colSpan={headers.length} sx={{ color: "#888" }}>
+            No data available.
+          </TableCell>
+        </TableRow>
+      </TableBody>
+    </Table>
+  );
+
+  const renderSoftware = () => {
+    const rows = details.software || [];
+    if (!rows.length) return placeholderTable(["Software Name", "Version", "Action"]);
+    return (
+      <Table size="small">
+        <TableHead>
+          <TableRow>
+            <TableCell>Software Name</TableCell>
+            <TableCell>Version</TableCell>
+            <TableCell>Action</TableCell>
+          </TableRow>
+        </TableHead>
+        <TableBody>
+          {rows.map((s, i) => (
+            <TableRow key={`${s.name}-${i}`}>
+              <TableCell>{s.name}</TableCell>
+              <TableCell>{s.version}</TableCell>
+              <TableCell></TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    );
+  };
+
+  const renderMemory = () => {
+    const rows = details.memory || [];
+    if (!rows.length) return placeholderTable(["Slot", "Speed", "Serial Number", "Capacity"]);
+    return (
+      <Table size="small">
+        <TableHead>
+          <TableRow>
+            <TableCell>Slot</TableCell>
+            <TableCell>Speed</TableCell>
+            <TableCell>Serial Number</TableCell>
+            <TableCell>Capacity</TableCell>
+          </TableRow>
+        </TableHead>
+        <TableBody>
+          {rows.map((m, i) => (
+            <TableRow key={`${m.slot}-${i}`}>
+              <TableCell>{m.slot}</TableCell>
+              <TableCell>{m.speed}</TableCell>
+              <TableCell>{m.serial}</TableCell>
+              <TableCell>{formatBytes(m.capacity)}</TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    );
+  };
+
+  const renderStorage = () => {
+    const rows = details.storage || [];
+    if (!rows.length)
+      return placeholderTable(["Drive Letter", "Disk Type", "Usage", "Total Size", "Free %"]);
+    return (
+      <Table size="small">
+        <TableHead>
+          <TableRow>
+            <TableCell>Drive Letter</TableCell>
+            <TableCell>Disk Type</TableCell>
+            <TableCell>Usage</TableCell>
+            <TableCell>Total Size</TableCell>
+            <TableCell>Free %</TableCell>
+          </TableRow>
+        </TableHead>
+        <TableBody>
+          {rows.map((d, i) => (
+            <TableRow key={`${d.drive}-${i}`}>
+              <TableCell>{d.drive}</TableCell>
+              <TableCell>{d.disk_type}</TableCell>
+              <TableCell>
+                {d.usage !== undefined && d.usage !== null && d.usage !== "unknown"
+                  ? `${d.usage.toFixed ? d.usage.toFixed(1) : d.usage}%`
+                  : "unknown"}
+              </TableCell>
+              <TableCell>{formatBytes(d.total)}</TableCell>
+              <TableCell>
+                {d.free !== undefined && d.free !== null && d.free !== "unknown"
+                  ? `${d.free.toFixed ? d.free.toFixed(1) : d.free}%`
+                  : "unknown"}
+              </TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    );
+  };
+
+  const renderNetwork = () => {
+    const rows = details.network || [];
+    if (!rows.length) return placeholderTable(["Adapter", "IP Address", "MAC Address"]);
+    return (
+      <Table size="small">
+        <TableHead>
+          <TableRow>
+            <TableCell>Adapter</TableCell>
+            <TableCell>IP Address</TableCell>
+            <TableCell>MAC Address</TableCell>
+          </TableRow>
+        </TableHead>
+        <TableBody>
+          {rows.map((n, i) => (
+            <TableRow key={`${n.adapter}-${i}`}>
+              <TableCell>{n.adapter}</TableCell>
+              <TableCell>{(n.ips || []).join(", ")}</TableCell>
+              <TableCell>{n.mac}</TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    );
+  };
+
+  const tabs = [
+    { label: "Summary", content: renderSummary() },
+    {
+      label: "Monitors",
+      content: placeholderTable([
+        "Type",
+        "Description",
+        "Latest Value",
+        "Policy",
+        "Latest 10 Days of Alerts",
+        "Enabled/Disabled Status"
+      ])
+    },
+    { label: "Software", content: renderSoftware() },
+    { label: "Memory", content: renderMemory() },
+    { label: "Storage", content: renderStorage() },
+    { label: "Network", content: renderNetwork() }
+  ];
+
+  return (
+    <Paper sx={{ m: 2, p: 2, bgcolor: "#1e1e1e" }} elevation={2}>
+      <Box sx={{ mb: 2, display: "flex", alignItems: "center" }}>
+        {onBack && (
+          <Button variant="outlined" size="small" onClick={onBack} sx={{ mr: 2 }}>
+            Back
+          </Button>
+        )}
+        <Typography variant="h6" sx={{ color: "#58a6ff" }}>
+          {agent.hostname || "Device Details"}
+        </Typography>
+      </Box>
+      <Tabs
+        value={tab}
+        onChange={(e, v) => setTab(v)}
+        sx={{ borderBottom: 1, borderColor: "#333" }}
+      >
+        {tabs.map((t) => (
+          <Tab key={t.label} label={t.label} />
+        ))}
+      </Tabs>
+      <Box sx={{ mt: 2 }}>{tabs[tab].content}</Box>
+    </Paper>
+  );
+}
+

Data/Server/WebUI/src/Device_List.jsx

@@ -35,7 +35,7 @@ function statusFromHeartbeat(tsSec, offlineAfter = 15) {
   return now - tsSec <= offlineAfter ? "Online" : "Offline";
 }
 
-export default function DeviceList() {
+export default function DeviceList({ onSelectDevice }) {
   const [rows, setRows] = useState([]);
   const [orderBy, setOrderBy] = useState("status");
   const [order, setOrder] = useState("desc");
@@ -165,7 +165,12 @@ export default function DeviceList() {
         </TableHead>
         <TableBody>
           {sorted.map((r, i) => (
-            <TableRow key={r.id || i} hover>
+            <TableRow
+              key={r.id || i}
+              hover
+              onClick={() => onSelectDevice && onSelectDevice(r)}
+              sx={{ cursor: onSelectDevice ? "pointer" : "default" }}
+            >
               <TableCell>
                 <span
                   style={{

Data/Server/server.py

@@ -379,6 +379,7 @@ def rename_workflow():
 registered_agents: Dict[str, Dict] = {}
 agent_configurations: Dict[str, Dict] = {}
 latest_images: Dict[str, Dict] = {}
+DEVICES_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "Devices"))
 
 @app.route("/api/agents")
 def get_agents():
@@ -388,6 +389,35 @@ def get_agents():
     return jsonify(registered_agents)
 
 
+@app.route("/api/agent/details", methods=["POST"])
+def save_agent_details():
+    data = request.get_json(silent=True) or {}
+    agent_id = data.get("agent_id")
+    details = data.get("details")
+    if not agent_id or not isinstance(details, dict):
+        return jsonify({"error": "invalid payload"}), 400
+    os.makedirs(DEVICES_ROOT, exist_ok=True)
+    path = os.path.join(DEVICES_ROOT, f"{agent_id}.json")
+    try:
+        with open(path, "w", encoding="utf-8") as fh:
+            json.dump(details, fh, indent=2)
+        return jsonify({"status": "ok"})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/agent/details/<agent_id>", methods=["GET"])
+def get_agent_details(agent_id: str):
+    path = os.path.join(DEVICES_ROOT, f"{agent_id}.json")
+    if os.path.isfile(path):
+        try:
+            with open(path, "r", encoding="utf-8") as fh:
+                return jsonify(json.load(fh))
+        except Exception:
+            pass
+    return jsonify({})
+
+
 @app.route("/api/agent/<agent_id>", methods=["DELETE"])
 def delete_agent(agent_id: str):
     """Remove an agent from the in-memory registry."""