From d7c991548d30b9479085240f807309d4d859ebb9 Mon Sep 17 00:00:00 2001
From: Nicole Rappe <nicole.rappe@bunny-lab.io>
Date: Wed, 8 Oct 2025 20:27:26 -0600
Subject: [PATCH 1/4] Refactor device inventory storage and API

---
 .../WebUI/src/Devices/Device_Details.jsx      |  31 +-
 Data/Server/WebUI/src/Devices/Device_List.jsx | 467 ++++++-----
 Data/Server/server.py                         | 760 +++++++++++++++---
 3 files changed, 923 insertions(+), 335 deletions(-)

diff --git a/Data/Server/WebUI/src/Devices/Device_Details.jsx b/Data/Server/WebUI/src/Devices/Device_Details.jsx
index 47bcbe59..5225bb5d 100644
--- a/Data/Server/WebUI/src/Devices/Device_Details.jsx
+++ b/Data/Server/WebUI/src/Devices/Device_Details.jsx
@@ -111,8 +111,35 @@ export default function DeviceDetails({ device, onBack }) {
           setAgent({ id: device.id, ...agentsData[device.id] });
         }
         const detailData = await detailsRes.json();
-        setDetails(detailData || {});
-        setDescription(detailData?.summary?.description || "");
+        const summary = detailData?.summary && typeof detailData.summary === 'object'
+          ? detailData.summary
+          : (detailData?.details?.summary || {});
+        const normalized = {
+          ...(detailData?.details || {}),
+          summary: summary || {},
+          memory: Array.isArray(detailData?.memory) ? detailData.memory : (detailData?.details?.memory || []),
+          network: Array.isArray(detailData?.network) ? detailData.network : (detailData?.details?.network || []),
+          software: Array.isArray(detailData?.software) ? detailData.software : (detailData?.details?.software || []),
+          storage: Array.isArray(detailData?.storage) ? detailData.storage : (detailData?.details?.storage || []),
+          cpu: detailData?.cpu || detailData?.details?.cpu || {},
+        };
+        if (detailData?.description) {
+          normalized.summary = { ...normalized.summary, description: detailData.description };
+        }
+        setDetails(normalized);
+        setDescription(normalized.summary?.description || detailData?.description || "");
+        setAgent((prev) => ({
+          ...(prev || {}),
+          id: device?.id || prev?.id,
+          hostname: device?.hostname || normalized.summary?.hostname || prev?.hostname,
+          agent_hash: detailData?.agent_hash || normalized.summary?.agent_hash || prev?.agent_hash,
+          agent_operating_system:
+            detailData?.operating_system ||
+            normalized.summary?.operating_system ||
+            prev?.agent_operating_system,
+          device_type: detailData?.device_type || normalized.summary?.device_type || prev?.device_type,
+          last_seen: detailData?.last_seen || normalized.summary?.last_seen || prev?.last_seen,
+        }));
       } catch (e) {
         console.warn("Failed to load device info", e);
       }
diff --git a/Data/Server/WebUI/src/Devices/Device_List.jsx b/Data/Server/WebUI/src/Devices/Device_List.jsx
index fdbe35ae..8e90c3e3 100644
--- a/Data/Server/WebUI/src/Devices/Device_List.jsx
+++ b/Data/Server/WebUI/src/Devices/Device_List.jsx
@@ -51,6 +51,21 @@ function statusFromHeartbeat(tsSec, offlineAfter = 300) {
   return now - tsSec <= offlineAfter ? "Online" : "Offline";
 }
 
+function formatUptime(seconds) {
+  const total = Number(seconds);
+  if (!Number.isFinite(total) || total <= 0) return "";
+  const parts = [];
+  const days = Math.floor(total / 86400);
+  if (days) parts.push(`${days}d`);
+  const hours = Math.floor((total % 86400) / 3600);
+  if (hours) parts.push(`${hours}h`);
+  const minutes = Math.floor((total % 3600) / 60);
+  if (minutes) parts.push(`${minutes}m`);
+  const secondsPart = Math.floor(total % 60);
+  if (!parts.length && secondsPart) parts.push(`${secondsPart}s`);
+  return parts.join(' ');
+}
+
 export default function DeviceList({ onSelectDevice }) {
   const [rows, setRows] = useState([]);
   const [orderBy, setOrderBy] = useState("status");
@@ -89,6 +104,17 @@ export default function DeviceList({ onSelectDevice }) {
       lastReboot: "Last Reboot",
       created: "Created",
       lastSeen: "Last Seen",
+      agentId: "Agent ID",
+      agentHash: "Agent Hash",
+      agentGuid: "Agent GUID",
+      domain: "Domain",
+      uptime: "Uptime",
+      memory: "Memory",
+      network: "Network",
+      software: "Software",
+      storage: "Storage",
+      cpu: "CPU",
+      siteDescription: "Site Description",
     }),
     []
   );
@@ -114,9 +140,6 @@ export default function DeviceList({ onSelectDevice }) {
   const [filters, setFilters] = useState({});
   const [filterAnchor, setFilterAnchor] = useState(null); // { id, anchorEl }
 
-  // Cache device details to avoid re-fetching every refresh
-  const [detailsByHost, setDetailsByHost] = useState({}); // hostname -> cached fields
-  const [siteMapping, setSiteMapping] = useState({}); // hostname -> { site_id, site_name }
   const [sites, setSites] = useState([]); // sites list for assignment
   const [assignDialogOpen, setAssignDialogOpen] = useState(false);
   const [assignSiteId, setAssignSiteId] = useState(null);
@@ -152,195 +175,182 @@ export default function DeviceList({ onSelectDevice }) {
     return agentHash === repo ? "Up-to-Date" : "Needs Updated";
   }, []);
 
-  const fetchAgents = useCallback(async (options = {}) => {
+  const fetchDevices = useCallback(async (options = {}) => {
     const { refreshRepo = false } = options || {};
     let repoSha = repoHash;
     if (refreshRepo || !repoSha) {
       const fetched = await fetchLatestRepoHash();
       if (fetched) repoSha = fetched;
     }
+
+    const hashById = new Map();
+    const hashByGuid = new Map();
+    const hashByHost = new Map();
     try {
-      const hashById = new Map();
-      const hashByGuid = new Map();
-      const hashByHost = new Map();
-      try {
-        const hashResp = await fetch('/api/agent/hash_list');
-        if (hashResp.ok) {
-          const hashJson = await hashResp.json();
-          const list = Array.isArray(hashJson?.agents) ? hashJson.agents : [];
-          list.forEach((rec) => {
-            if (!rec || typeof rec !== 'object') return;
-            const hash = (rec.agent_hash || '').trim();
-            if (!hash) return;
-            const agentId = (rec.agent_id || '').trim();
-            const guidRaw = (rec.agent_guid || '').trim().toLowerCase();
-            const hostKey = (rec.hostname || '').trim().toLowerCase();
-            const isMemory = (rec.source || '').trim() === 'memory';
-            if (agentId && (!hashById.has(agentId) || isMemory)) {
-              hashById.set(agentId, hash);
-            }
-            if (guidRaw && (!hashByGuid.has(guidRaw) || isMemory)) {
-              hashByGuid.set(guidRaw, hash);
-            }
-            if (hostKey && (!hashByHost.has(hostKey) || isMemory)) {
-              hashByHost.set(hostKey, hash);
-            }
-          });
-        } else {
+      const hashResp = await fetch('/api/agent/hash_list');
+      if (hashResp.ok) {
+        const hashJson = await hashResp.json();
+        const list = Array.isArray(hashJson?.agents) ? hashJson.agents : [];
+        list.forEach((rec) => {
+          if (!rec || typeof rec !== 'object') return;
+          const hash = (rec.agent_hash || '').trim();
+          if (!hash) return;
+          const agentId = (rec.agent_id || '').trim();
+          const guidRaw = (rec.agent_guid || '').trim().toLowerCase();
+          const hostKey = (rec.hostname || '').trim().toLowerCase();
+          const isMemory = (rec.source || '').trim() === 'memory';
+          if (agentId && (!hashById.has(agentId) || isMemory)) {
+            hashById.set(agentId, hash);
+          }
+          if (guidRaw && (!hashByGuid.has(guidRaw) || isMemory)) {
+            hashByGuid.set(guidRaw, hash);
+          }
+          if (hostKey && (!hashByHost.has(hostKey) || isMemory)) {
+            hashByHost.set(hostKey, hash);
+          }
+        });
+      }
+    } catch (err) {
+      console.warn('Failed to fetch agent hash list', err);
+    }
+
+    try {
+      const res = await fetch('/api/devices');
+      if (!res.ok) {
+        const err = new Error(`Failed to fetch devices (${res.status})`);
+        try {
+          err.response = await res.json();
+        } catch {}
+        throw err;
+      }
+      const payload = await res.json();
+      const list = Array.isArray(payload?.devices) ? payload.devices : [];
+
+      const normalizeJson = (value) => {
+        if (!value) return '';
+        try {
+          return JSON.stringify(value);
+        } catch {
+          return '';
+        }
+      };
+
+      const normalized = list.map((device, index) => {
+        const summary = device && typeof device.summary === 'object' ? { ...device.summary } : {};
+        const rawHostname = (device.hostname || summary.hostname || '').trim();
+        const hostname = rawHostname || `device-${index + 1}`;
+        const agentId = (device.agent_id || summary.agent_id || '').trim();
+        const id = agentId || hostname || `device-${index + 1}`;
+        const guidRaw = (device.agent_guid || summary.agent_guid || '').trim();
+        const guidLookupKey = guidRaw.toLowerCase();
+        let agentHash = (device.agent_hash || summary.agent_hash || '').trim();
+        if (agentId && hashById.has(agentId)) agentHash = hashById.get(agentId) || agentHash;
+        if (!agentHash && guidLookupKey && hashByGuid.has(guidLookupKey)) {
+          agentHash = hashByGuid.get(guidLookupKey) || agentHash;
+        }
+        const hostKey = hostname.trim().toLowerCase();
+        if (!agentHash && hostKey && hashByHost.has(hostKey)) {
+          agentHash = hashByHost.get(hostKey) || agentHash;
+        }
+        const lastSeen = Number(device.last_seen || summary.last_seen || 0) || 0;
+        const status = device.status || statusFromHeartbeat(lastSeen);
+
+        if (guidRaw && !summary.agent_guid) {
+          summary.agent_guid = guidRaw;
+        }
+
+        let createdTs = Number(device.created_at || 0) || 0;
+        let createdDisplay = summary.created || '';
+        if (!createdTs && createdDisplay) {
+          const parsed = Date.parse(createdDisplay.replace(' ', 'T'));
+          if (!Number.isNaN(parsed)) createdTs = Math.floor(parsed / 1000);
+        }
+        if (!createdDisplay && device.created_at_iso) {
           try {
-            const errPayload = await hashResp.json();
-            if (errPayload?.error) {
-              console.warn('Failed to fetch agent hash list', errPayload.error);
-            }
+            createdDisplay = new Date(device.created_at_iso).toLocaleString();
           } catch {}
         }
-      } catch (err) {
-        console.warn('Failed to fetch agent hash list', err);
-      }
 
-      const res = await fetch("/api/agents");
-      const data = await res.json();
-      const arr = Object.entries(data || {}).map(([id, a]) => {
-        const agentId = (id || '').trim();
-        const hostname = a.hostname || agentId || "unknown";
-        const normalizedHostKey = (hostname || '').trim().toLowerCase();
-        const details = detailsByHost[hostname] || {};
-        const rawGuid = (a.agent_guid || a.agentGuid || a.guid || '').trim();
-        const detailGuid = (details.agentGuid || details.agent_guid || '').trim();
-        const guidCandidates = [rawGuid, detailGuid].filter((g) => g && g.trim());
-        let agentHash = '';
-        if (agentId && hashById.has(agentId)) {
-          agentHash = hashById.get(agentId) || '';
-        }
-        if (!agentHash) {
-          for (const candidate of guidCandidates) {
-            const key = (candidate || '').trim().toLowerCase();
-            if (key && hashByGuid.has(key)) {
-              agentHash = hashByGuid.get(key) || '';
-              break;
-            }
-          }
-        }
-        if (!agentHash && normalizedHostKey && hashByHost.has(normalizedHostKey)) {
-          agentHash = hashByHost.get(normalizedHostKey) || '';
-        }
-        if (!agentHash) {
-          agentHash = (a.agent_hash || details.agentHash || '').trim();
-        }
-        const agentGuidValue = rawGuid || detailGuid || '';
+        const osName =
+          device.operating_system ||
+          summary.operating_system ||
+          summary.agent_operating_system ||
+          "-";
+        const type = (device.device_type || summary.device_type || '').trim();
+        const lastUser = (device.last_user || summary.last_user || '').trim();
+        const domain = (device.domain || summary.domain || '').trim();
+        const internalIp = (device.internal_ip || summary.internal_ip || '').trim();
+        const externalIp = (device.external_ip || summary.external_ip || '').trim();
+        const lastReboot = (device.last_reboot || summary.last_reboot || '').trim();
+        const uptimeSeconds = Number(
+          device.uptime ||
+            summary.uptime_sec ||
+            summary.uptime_seconds ||
+            summary.uptime ||
+            0
+        ) || 0;
+
+        const memoryList = Array.isArray(device.memory) ? device.memory : [];
+        const networkList = Array.isArray(device.network) ? device.network : [];
+        const softwareList = Array.isArray(device.software) ? device.software : [];
+        const storageList = Array.isArray(device.storage) ? device.storage : [];
+        const cpuObj =
+          (device.cpu && typeof device.cpu === 'object' && device.cpu) ||
+          (summary.cpu && typeof summary.cpu === 'object' ? summary.cpu : {});
+
+        const memoryDisplay = memoryList.length ? `${memoryList.length} module(s)` : '';
+        const networkDisplay = networkList.length ? networkList.map((n) => n.adapter || n.name || '').filter(Boolean).join(', ') : '';
+        const softwareDisplay = softwareList.length ? `${softwareList.length} item(s)` : '';
+        const storageDisplay = storageList.length ? `${storageList.length} volume(s)` : '';
+        const cpuDisplay = cpuObj.name || summary.processor || '';
+
         return {
           id,
           hostname,
-          status: statusFromHeartbeat(a.last_seen),
-          lastSeen: a.last_seen || 0,
-          os: a.agent_operating_system || a.os || "-",
-          // Enriched fields from details cache
-          lastUser: details.lastUser || "",
-          type: a.device_type || details.type || "",
-          created: details.created || "",
-          createdTs: details.createdTs || 0,
-          internalIp: details.internalIp || "",
-          externalIp: details.externalIp || "",
-          lastReboot: details.lastReboot || "",
-          description: details.description || "",
-          agentGuid: agentGuidValue,
+          status,
+          lastSeen,
+          lastSeenDisplay: formatLastSeen(lastSeen),
+          os: osName,
+          lastUser,
+          type,
+          site: device.site_name || 'Not Configured',
+          siteId: device.site_id || null,
+          siteDescription: device.site_description || '',
+          description: (device.description || summary.description || '').trim(),
+          created: createdDisplay,
+          createdTs,
+          createdIso: device.created_at_iso || '',
+          agentGuid: guidRaw,
           agentHash,
           agentVersion: computeAgentVersion(agentHash, repoSha),
+          agentId,
+          domain,
+          internalIp,
+          externalIp,
+          lastReboot,
+          uptime: uptimeSeconds,
+          uptimeDisplay: formatUptime(uptimeSeconds),
+          memory: memoryDisplay,
+          memoryRaw: normalizeJson(memoryList),
+          network: networkDisplay,
+          networkRaw: normalizeJson(networkList),
+          software: softwareDisplay,
+          softwareRaw: normalizeJson(softwareList),
+          storage: storageDisplay,
+          storageRaw: normalizeJson(storageList),
+          cpu: cpuDisplay,
+          cpuRaw: normalizeJson(cpuObj),
+          summary,
+          details: device.details || {},
         };
       });
-      setRows(arr);
 
-      // Fetch site mapping for these hostnames
-      try {
-        const hostCsv = arr.map((r) => r.hostname).filter(Boolean).map(encodeURIComponent).join(',');
-        const resp = await fetch(`/api/sites/device_map?hostnames=${hostCsv}`);
-        const mapData = await resp.json();
-        const mapping = mapData?.mapping || {};
-        setSiteMapping(mapping);
-        setRows((prev) => prev.map((r) => ({ ...r, site: mapping[r.hostname]?.site_name || "Not Configured" })));
-      } catch {}
-
-      // Fetch missing details (last_user, created) for hosts not cached yet
-      const hostsToFetch = arr
-        .map((r) => r.hostname)
-        .filter((h) => h && !detailsByHost[h]);
-      if (hostsToFetch.length) {
-        // Limit concurrency a bit
-        const chunks = [];
-        const size = 6;
-        for (let i = 0; i < hostsToFetch.length; i += size) {
-          chunks.push(hostsToFetch.slice(i, i + size));
-        }
-        for (const chunk of chunks) {
-          await Promise.all(
-            chunk.map(async (h) => {
-              try {
-                const resp = await fetch(`/api/device/details/${encodeURIComponent(h)}`);
-                const det = await resp.json();
-                const summary = det?.summary || {};
-                const lastUser = summary.last_user || "";
-                const createdRaw = summary.created || "";
-                // Try to parse created to epoch seconds for sorting; fallback to 0
-                let createdTs = 0;
-                if (createdRaw) {
-                  const parsed = Date.parse(createdRaw.replace(" ", "T"));
-                  createdTs = isNaN(parsed) ? 0 : Math.floor(parsed / 1000);
-                }
-                const deviceType = (summary.device_type || "").trim();
-                const internalIp = summary.internal_ip || "";
-                const externalIp = summary.external_ip || "";
-                const lastReboot = summary.last_reboot || "";
-                const description = summary.description || "";
-                const agentHashValue = (summary.agent_hash || "").trim();
-                const agentGuidValue = (summary.agent_guid || summary.agentGuid || "").trim();
-                const enriched = {
-                  lastUser,
-                  created: createdRaw,
-                  createdTs,
-                  type: deviceType,
-                  internalIp,
-                  externalIp,
-                  lastReboot,
-                  description,
-                  agentHash: agentHashValue,
-                  agentGuid: agentGuidValue,
-                };
-                setDetailsByHost((prev) => ({
-                  ...prev,
-                  [h]: enriched,
-                }));
-                setRows((prev) =>
-                  prev.map((r) => {
-                    if (r.hostname !== h) return r;
-                    const nextHash = agentHashValue || r.agentHash;
-                    return {
-                      ...r,
-                      lastUser: enriched.lastUser || r.lastUser,
-                      type: enriched.type || r.type,
-                      created: enriched.created || r.created,
-                      createdTs: enriched.createdTs || r.createdTs,
-                      internalIp: enriched.internalIp || r.internalIp,
-                      externalIp: enriched.externalIp || r.externalIp,
-                      lastReboot: enriched.lastReboot || r.lastReboot,
-                      description: enriched.description || r.description,
-                      agentGuid: agentGuidValue || r.agentGuid || "",
-                      agentHash: nextHash,
-                      agentVersion: computeAgentVersion(nextHash, repoSha),
-                    };
-                  })
-                );
-              } catch {
-                // ignore per-host failure
-              }
-            })
-          );
-        }
-      }
+      setRows(normalized);
     } catch (e) {
-      console.warn("Failed to load agents:", e);
+      console.warn('Failed to load devices:', e);
       setRows([]);
     }
-  }, [detailsByHost, repoHash, fetchLatestRepoHash, computeAgentVersion]);
+  }, [repoHash, fetchLatestRepoHash, computeAgentVersion]);
 
   const fetchViews = useCallback(async () => {
     try {
@@ -355,8 +365,8 @@ export default function DeviceList({ onSelectDevice }) {
 
   useEffect(() => {
     // Initial load only; removed auto-refresh interval
-    fetchAgents({ refreshRepo: true });
-  }, [fetchAgents]);
+    fetchDevices({ refreshRepo: true });
+  }, [fetchDevices]);
 
   useEffect(() => {
     fetchViews();
@@ -471,6 +481,28 @@ export default function DeviceList({ onSelectDevice }) {
           return formatCreated(row.created, row.createdTs);
         case "lastSeen":
           return formatLastSeen(row.lastSeen);
+        case "agentId":
+          return row.agentId || "";
+        case "agentHash":
+          return row.agentHash || "";
+        case "agentGuid":
+          return row.agentGuid || "";
+        case "domain":
+          return row.domain || "";
+        case "uptime":
+          return row.uptimeDisplay || (row.uptime ? String(row.uptime) : "");
+        case "memory":
+          return row.memoryRaw || row.memory || "";
+        case "network":
+          return row.networkRaw || row.network || "";
+        case "software":
+          return row.softwareRaw || row.software || "";
+        case "storage":
+          return row.storageRaw || row.storage || "";
+        case "cpu":
+          return row.cpuRaw || row.cpu || "";
+        case "siteDescription":
+          return row.siteDescription || "";
         default:
           return "";
       }
@@ -485,9 +517,10 @@ export default function DeviceList({ onSelectDevice }) {
   const sorted = useMemo(() => {
     const dir = order === "asc" ? 1 : -1;
     return [...filtered].sort((a, b) => {
-      // Support numeric sort for created/lastSeen
+      // Support numeric sort for created/lastSeen/uptime
       if (orderBy === "lastSeen") return ((a.lastSeen || 0) - (b.lastSeen || 0)) * dir;
       if (orderBy === "created") return ((a.createdTs || 0) - (b.createdTs || 0)) * dir;
+      if (orderBy === "uptime") return ((a.uptime || 0) - (b.uptime || 0)) * dir;
       const A = a[orderBy];
       const B = b[orderBy];
       return String(A || "").localeCompare(String(B || "")) * dir;
@@ -682,7 +715,7 @@ export default function DeviceList({ onSelectDevice }) {
             <Tooltip title="Refresh Devices to Detect Changes">
               <IconButton
                 size="small"
-                onClick={() => fetchAgents({ refreshRepo: true })}
+                onClick={() => fetchDevices({ refreshRepo: true })}
                 sx={{ color: "#bbb", mr: 1 }}
               >
                 <CachedIcon fontSize="small" />
@@ -830,8 +863,30 @@ export default function DeviceList({ onSelectDevice }) {
                     return (
                       <TableCell key={col.id}>{formatLastSeen(r.lastSeen)}</TableCell>
                     );
+                  case "agentId":
+                    return <TableCell key={col.id}>{r.agentId || ""}</TableCell>;
+                  case "agentHash":
+                    return <TableCell key={col.id}>{r.agentHash || ""}</TableCell>;
+                  case "agentGuid":
+                    return <TableCell key={col.id}>{r.agentGuid || ""}</TableCell>;
+                  case "domain":
+                    return <TableCell key={col.id}>{r.domain || ""}</TableCell>;
+                  case "uptime":
+                    return <TableCell key={col.id}>{r.uptimeDisplay || ''}</TableCell>;
+                  case "memory":
+                    return <TableCell key={col.id}>{r.memory || ""}</TableCell>;
+                  case "network":
+                    return <TableCell key={col.id}>{r.network || ""}</TableCell>;
+                  case "software":
+                    return <TableCell key={col.id}>{r.software || ""}</TableCell>;
+                  case "storage":
+                    return <TableCell key={col.id}>{r.storage || ""}</TableCell>;
+                  case "cpu":
+                    return <TableCell key={col.id}>{r.cpu || ""}</TableCell>;
+                  case "siteDescription":
+                    return <TableCell key={col.id}>{r.siteDescription || ""}</TableCell>;
                   default:
-                    return <TableCell key={col.id} />;
+                    return <TableCell key={col.id}>{String(r[col.id] || "")}</TableCell>;
                 }
               })}
               <TableCell align="right">
@@ -952,44 +1007,30 @@ export default function DeviceList({ onSelectDevice }) {
         PaperProps={{ sx: { bgcolor: "#1e1e1e", color: '#fff', p: 1 } }}
       >
         <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5, p: 1 }}>
-          {[ 
-            { id: 'agentVersion', label: 'Agent Version' },
-            { id: 'site', label: 'Site' },
-            { id: 'hostname', label: 'Hostname' },
-            { id: 'os', label: 'Operating System' },
-            { id: 'type', label: 'Device Type' },
-            { id: 'lastUser', label: 'Last User' },
-            { id: 'internalIp', label: 'Internal IP' },
-            { id: 'externalIp', label: 'External IP' },
-            { id: 'lastReboot', label: 'Last Reboot' },
-            { id: 'created', label: 'Created' },
-            { id: 'lastSeen', label: 'Last Seen' },
-            { id: 'description', label: 'Description' },
-          ].map((opt) => (
-            <MenuItem key={opt.id} disableRipple onClick={(e) => e.stopPropagation()} sx={{ gap: 1 }}>
-              <Checkbox
-                size="small"
-                checked={columns.some((c) => c.id === opt.id)}
-                onChange={(e) => {
-                  const checked = e.target.checked;
-                  setColumns((prev) => {
-                    // Keep 'status' always present; manage others per toggle
-                    const exists = prev.some((c) => c.id === opt.id);
-                    if (checked) {
-                      if (exists) return prev;
-                      // Append new column at the end with canonical label
-                      const label = COL_LABELS[opt.id] || opt.label || opt.id;
-                      return [...prev, { id: opt.id, label }];
-                    }
-                    // Remove column
-                    return prev.filter((c) => c.id !== opt.id);
-                  });
-                }}
-                sx={{ p: 0.3, color: '#bbb' }}
-              />
-              <Typography variant="body2" sx={{ color: '#ddd' }}>{opt.label}</Typography>
-            </MenuItem>
-          ))}
+          {Object.entries(COL_LABELS)
+            .filter(([id]) => id !== 'status')
+            .map(([id, label]) => (
+              <MenuItem key={id} disableRipple onClick={(e) => e.stopPropagation()} sx={{ gap: 1 }}>
+                <Checkbox
+                  size="small"
+                  checked={columns.some((c) => c.id === id)}
+                  onChange={(e) => {
+                    const checked = e.target.checked;
+                    setColumns((prev) => {
+                      const exists = prev.some((c) => c.id === id);
+                      if (checked) {
+                        if (exists) return prev;
+                        const nextLabel = COL_LABELS[id] || label || id;
+                        return [...prev, { id, label: nextLabel }];
+                      }
+                      return prev.filter((c) => c.id !== id);
+                    });
+                  }}
+                  sx={{ p: 0.3, color: '#bbb' }}
+                />
+                <Typography variant="body2" sx={{ color: '#ddd' }}>{label || id}</Typography>
+              </MenuItem>
+            ))}
           <Box sx={{ display: 'flex', gap: 1, pt: 0.5 }}>
             <Button
               size="small"
diff --git a/Data/Server/server.py b/Data/Server/server.py
index a2be8a2c..a2f7e150 100644
--- a/Data/Server/server.py
+++ b/Data/Server/server.py
@@ -463,7 +463,7 @@ def _lookup_agent_hash_record(agent_id: str) -> Optional[Dict[str, Any]]:
                 if row_guid:
                     payload['agent_guid'] = row_guid
                 return payload
-        cur.execute('SELECT hostname, agent_hash, details, guid FROM device_details')
+        cur.execute(f'SELECT hostname, agent_hash, details, guid FROM {DEVICE_TABLE}')
         for host, db_hash, details_json, row_guid in cur.fetchall():
             try:
                 data = json.loads(details_json or '{}')
@@ -528,7 +528,7 @@ def _lookup_agent_hash_by_guid(agent_guid: str) -> Optional[Dict[str, Any]]:
         conn = _db_conn()
         cur = conn.cursor()
         cur.execute(
-            'SELECT hostname, agent_hash, details FROM device_details WHERE guid = ?',
+            f'SELECT hostname, agent_hash, details FROM {DEVICE_TABLE} WHERE guid = ?',
             (normalized_guid,),
         )
         row = cur.fetchone()
@@ -638,7 +638,7 @@ def _collect_agent_hash_records() -> List[Dict[str, Any]]:
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        cur.execute('SELECT hostname, agent_hash, details, guid FROM device_details')
+        cur.execute(f'SELECT hostname, agent_hash, details, guid FROM {DEVICE_TABLE}')
         for hostname, stored_hash, details_json, row_guid in cur.fetchall():
             try:
                 details = json.loads(details_json or '{}')
@@ -719,15 +719,16 @@ def _apply_agent_hash_update(agent_id: str, agent_hash: str, agent_guid: Optiona
         updated_via_guid = False
         if normalized_guid:
             cur.execute(
-                'SELECT hostname, details FROM device_details WHERE guid = ?',
+                f'SELECT hostname, description, details, created_at, agent_hash FROM {DEVICE_TABLE} WHERE guid = ?',
                 (normalized_guid,),
             )
             row = cur.fetchone()
             if row:
                 updated_via_guid = True
                 hostname = row[0]
+                description = row[1]
                 try:
-                    details = json.loads(row[1] or '{}')
+                    details = json.loads(row[2] or '{}')
                 except Exception:
                     details = {}
                 summary = details.setdefault('summary', {})
@@ -737,9 +738,16 @@ def _apply_agent_hash_update(agent_id: str, agent_hash: str, agent_guid: Optiona
                     summary['agent_id'] = resolved_agent_id
                 summary['agent_hash'] = agent_hash
                 summary['agent_guid'] = normalized_guid
-                cur.execute(
-                    'UPDATE device_details SET agent_hash=?, details=? WHERE hostname=?',
-                    (agent_hash, json.dumps(details), hostname),
+                existing_created_at = row[3] if len(row) > 3 else None
+                existing_hash = row[4] if len(row) > 4 else None
+                _device_upsert(
+                    cur,
+                    hostname,
+                    description,
+                    details,
+                    existing_created_at,
+                    agent_hash=agent_hash or existing_hash,
+                    guid=normalized_guid,
                 )
                 conn.commit()
             elif not agent_id:
@@ -774,8 +782,22 @@ def _apply_agent_hash_update(agent_id: str, agent_hash: str, agent_guid: Optiona
                 if resolved_agent_id:
                     summary['agent_id'] = resolved_agent_id
                 cur.execute(
-                    'UPDATE device_details SET agent_hash=?, details=? WHERE hostname=?',
-                    (agent_hash, json.dumps(details), hostname),
+                    f'SELECT description, created_at, agent_hash FROM {DEVICE_TABLE} WHERE hostname = ?',
+                    (hostname,),
+                )
+                info_row = cur.fetchone()
+                description = info_row[0] if info_row else None
+                existing_created_at = info_row[1] if info_row else None
+                existing_hash = info_row[2] if info_row else None
+                effective_guid = normalized_guid or target.get('guid')
+                _device_upsert(
+                    cur,
+                    hostname,
+                    description,
+                    details,
+                    existing_created_at,
+                    agent_hash=agent_hash or existing_hash,
+                    guid=effective_guid,
                 )
                 conn.commit()
                 if not normalized_guid:
@@ -1054,6 +1076,7 @@ def api_login():
         cur.execute("UPDATE users SET last_login=?, updated_at=? WHERE id=?", (now, now, row[0]))
         conn.commit()
         conn.commit()
+        conn.commit()
         conn.close()
         # set session cookie
         session['username'] = row[1]
@@ -2427,6 +2450,203 @@ latest_images: Dict[str, Dict] = {}
 DB_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "database.db"))
 os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
 
+DEVICE_TABLE = "devices"
+_DEVICE_JSON_LIST_FIELDS = {
+    "memory": [],
+    "network": [],
+    "software": [],
+    "storage": [],
+}
+_DEVICE_JSON_OBJECT_FIELDS = {
+    "cpu": {},
+}
+
+
+def _serialize_device_json(value: Any, default: Any) -> str:
+    candidate = value
+    if candidate is None:
+        candidate = default
+    if not isinstance(candidate, (list, dict)):
+        candidate = default
+    try:
+        return json.dumps(candidate)
+    except Exception:
+        try:
+            return json.dumps(default)
+        except Exception:
+            return "{}" if isinstance(default, dict) else "[]"
+
+
+def _clean_device_str(value: Any) -> Optional[str]:
+    if value is None:
+        return None
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        text = str(value)
+    elif isinstance(value, str):
+        text = value
+    else:
+        try:
+            text = str(value)
+        except Exception:
+            return None
+    text = text.strip()
+    return text or None
+
+
+def _coerce_int(value: Any) -> Optional[int]:
+    if value is None:
+        return None
+    try:
+        if isinstance(value, str) and value.strip() == "":
+            return None
+        return int(float(value))
+    except (ValueError, TypeError):
+        return None
+
+
+def _extract_device_columns(details: Dict[str, Any]) -> Dict[str, Any]:
+    summary = details.get("summary") or {}
+    payload = {}
+
+    for field, default in _DEVICE_JSON_LIST_FIELDS.items():
+        payload[field] = _serialize_device_json(details.get(field), default)
+    payload["cpu"] = _serialize_device_json(summary.get("cpu") or details.get("cpu"), _DEVICE_JSON_OBJECT_FIELDS["cpu"])
+
+    payload["device_type"] = _clean_device_str(summary.get("device_type") or summary.get("type"))
+    payload["domain"] = _clean_device_str(summary.get("domain"))
+    payload["external_ip"] = _clean_device_str(summary.get("external_ip") or summary.get("public_ip"))
+    payload["internal_ip"] = _clean_device_str(summary.get("internal_ip") or summary.get("private_ip"))
+    payload["last_reboot"] = _clean_device_str(summary.get("last_reboot") or summary.get("last_boot"))
+    payload["last_seen"] = _coerce_int(summary.get("last_seen"))
+    payload["last_user"] = _clean_device_str(
+        summary.get("last_user")
+        or summary.get("last_user_name")
+        or summary.get("username")
+    )
+    payload["operating_system"] = _clean_device_str(
+        summary.get("operating_system")
+        or summary.get("agent_operating_system")
+        or summary.get("os")
+    )
+    uptime_value = (
+        summary.get("uptime_sec")
+        or summary.get("uptime_seconds")
+        or summary.get("uptime")
+    )
+    payload["uptime"] = _coerce_int(uptime_value)
+    payload["agent_id"] = _clean_device_str(summary.get("agent_id"))
+    return payload
+
+
+def _device_upsert(
+    cur: sqlite3.Cursor,
+    hostname: str,
+    description: Optional[str],
+    merged_details: Dict[str, Any],
+    created_at: Optional[int],
+    *,
+    agent_hash: Optional[str] = None,
+    guid: Optional[str] = None,
+) -> None:
+    if not hostname:
+        return
+    try:
+        details_json = json.dumps(merged_details or {})
+    except Exception:
+        details_json = json.dumps({})
+    column_values = _extract_device_columns(merged_details or {})
+
+    normalized_description = description if description is not None else ""
+    try:
+        normalized_description = str(normalized_description)
+    except Exception:
+        normalized_description = ""
+
+    normalized_hash = _clean_device_str(agent_hash) or None
+    normalized_guid = _clean_device_str(guid) or None
+    if normalized_guid:
+        try:
+            normalized_guid = _normalize_guid(normalized_guid)
+        except Exception:
+            pass
+
+    created_ts = _coerce_int(created_at)
+    if not created_ts:
+        created_ts = int(time.time())
+
+    sql = f"""
+        INSERT INTO {DEVICE_TABLE}(
+            hostname,
+            description,
+            details,
+            created_at,
+            agent_hash,
+            guid,
+            memory,
+            network,
+            software,
+            storage,
+            cpu,
+            device_type,
+            domain,
+            external_ip,
+            internal_ip,
+            last_reboot,
+            last_seen,
+            last_user,
+            operating_system,
+            uptime,
+            agent_id
+        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        ON CONFLICT(hostname) DO UPDATE SET
+            description=excluded.description,
+            details=excluded.details,
+            created_at=COALESCE({DEVICE_TABLE}.created_at, excluded.created_at),
+            agent_hash=COALESCE(NULLIF(excluded.agent_hash, ''), {DEVICE_TABLE}.agent_hash),
+            guid=COALESCE(NULLIF(excluded.guid, ''), {DEVICE_TABLE}.guid),
+            memory=excluded.memory,
+            network=excluded.network,
+            software=excluded.software,
+            storage=excluded.storage,
+            cpu=excluded.cpu,
+            device_type=COALESCE(NULLIF(excluded.device_type, ''), {DEVICE_TABLE}.device_type),
+            domain=COALESCE(NULLIF(excluded.domain, ''), {DEVICE_TABLE}.domain),
+            external_ip=COALESCE(NULLIF(excluded.external_ip, ''), {DEVICE_TABLE}.external_ip),
+            internal_ip=COALESCE(NULLIF(excluded.internal_ip, ''), {DEVICE_TABLE}.internal_ip),
+            last_reboot=COALESCE(NULLIF(excluded.last_reboot, ''), {DEVICE_TABLE}.last_reboot),
+            last_seen=COALESCE(NULLIF(excluded.last_seen, 0), {DEVICE_TABLE}.last_seen),
+            last_user=COALESCE(NULLIF(excluded.last_user, ''), {DEVICE_TABLE}.last_user),
+            operating_system=COALESCE(NULLIF(excluded.operating_system, ''), {DEVICE_TABLE}.operating_system),
+            uptime=COALESCE(NULLIF(excluded.uptime, 0), {DEVICE_TABLE}.uptime),
+            agent_id=COALESCE(NULLIF(excluded.agent_id, ''), {DEVICE_TABLE}.agent_id)
+    """
+
+    params: List[Any] = [
+        hostname,
+        normalized_description,
+        details_json,
+        created_ts,
+        normalized_hash,
+        normalized_guid,
+        column_values.get("memory"),
+        column_values.get("network"),
+        column_values.get("software"),
+        column_values.get("storage"),
+        column_values.get("cpu"),
+        column_values.get("device_type"),
+        column_values.get("domain"),
+        column_values.get("external_ip"),
+        column_values.get("internal_ip"),
+        column_values.get("last_reboot"),
+        column_values.get("last_seen"),
+        column_values.get("last_user"),
+        column_values.get("operating_system"),
+        column_values.get("uptime"),
+        column_values.get("agent_id"),
+    ]
+    cur.execute(sql, params)
+
+
 # --- Simple at-rest secret handling for service account passwords ---
 _SERVER_SECRET_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), 'server_secret.key'))
 
@@ -2514,20 +2734,101 @@ def init_db():
     conn = _db_conn()
     cur = conn.cursor()
 
-    # Device details table
+    # Device table (renamed from historical device_details)
     cur.execute(
-        "CREATE TABLE IF NOT EXISTS device_details (hostname TEXT PRIMARY KEY, description TEXT, details TEXT, created_at INTEGER, agent_hash TEXT, guid TEXT)"
+        "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+        (DEVICE_TABLE,),
     )
-    # Backfill missing created_at column on existing installs
+    has_devices = cur.fetchone()
+    if not has_devices:
+        cur.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='device_details'"
+        )
+        legacy = cur.fetchone()
+        if legacy:
+            cur.execute("ALTER TABLE device_details RENAME TO devices")
+        else:
+            cur.execute(
+                """
+                CREATE TABLE IF NOT EXISTS devices (
+                    hostname TEXT PRIMARY KEY,
+                    description TEXT,
+                    details TEXT,
+                    created_at INTEGER,
+                    agent_hash TEXT,
+                    guid TEXT,
+                    memory TEXT,
+                    network TEXT,
+                    software TEXT,
+                    storage TEXT,
+                    cpu TEXT,
+                    device_type TEXT,
+                    domain TEXT,
+                    external_ip TEXT,
+                    internal_ip TEXT,
+                    last_reboot TEXT,
+                    last_seen INTEGER,
+                    last_user TEXT,
+                    operating_system TEXT,
+                    uptime INTEGER,
+                    agent_id TEXT
+                )
+                """
+            )
+
+    # Ensure required columns exist on upgraded installs
+    cur.execute(f"PRAGMA table_info({DEVICE_TABLE})")
+    existing_cols = [r[1] for r in cur.fetchall()]
+
+    def _ensure_column(name: str, decl: str) -> None:
+        if name not in existing_cols:
+            cur.execute(f"ALTER TABLE {DEVICE_TABLE} ADD COLUMN {name} {decl}")
+            existing_cols.append(name)
+
+    _ensure_column("description", "TEXT")
+    _ensure_column("details", "TEXT")
+    _ensure_column("created_at", "INTEGER")
+    _ensure_column("agent_hash", "TEXT")
+    _ensure_column("guid", "TEXT")
+    _ensure_column("memory", "TEXT")
+    _ensure_column("network", "TEXT")
+    _ensure_column("software", "TEXT")
+    _ensure_column("storage", "TEXT")
+    _ensure_column("cpu", "TEXT")
+    _ensure_column("device_type", "TEXT")
+    _ensure_column("domain", "TEXT")
+    _ensure_column("external_ip", "TEXT")
+    _ensure_column("internal_ip", "TEXT")
+    _ensure_column("last_reboot", "TEXT")
+    _ensure_column("last_seen", "INTEGER")
+    _ensure_column("last_user", "TEXT")
+    _ensure_column("operating_system", "TEXT")
+    _ensure_column("uptime", "INTEGER")
+    _ensure_column("agent_id", "TEXT")
+
+    # Backfill expanded columns from stored JSON
     try:
-        cur.execute("PRAGMA table_info(device_details)")
-        cols = [r[1] for r in cur.fetchall()]
-        if 'created_at' not in cols:
-            cur.execute("ALTER TABLE device_details ADD COLUMN created_at INTEGER")
-        if 'agent_hash' not in cols:
-            cur.execute("ALTER TABLE device_details ADD COLUMN agent_hash TEXT")
-        if 'guid' not in cols:
-            cur.execute("ALTER TABLE device_details ADD COLUMN guid TEXT")
+        cur.execute(f"SELECT hostname, details FROM {DEVICE_TABLE}")
+        rows = cur.fetchall()
+        for hostname, details_json in rows:
+            try:
+                details = json.loads(details_json or "{}")
+            except Exception:
+                details = {}
+            column_values = _extract_device_columns(details)
+            update_fields = []
+            params: List[Any] = []
+            for key, value in column_values.items():
+                if key not in existing_cols:
+                    continue
+                update_fields.append(f"{key}=?")
+                params.append(value)
+            if update_fields:
+                params.append(hostname)
+                cur.execute(
+                    f"UPDATE {DEVICE_TABLE} SET {', '.join(update_fields)} WHERE hostname=?",
+                    params,
+                )
     except Exception:
         pass
 
@@ -2986,7 +3287,9 @@ def _load_device_records(limit: int = 0):
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        cur.execute("SELECT hostname, description, details FROM device_details")
+        cur.execute(
+            f"SELECT hostname, description, last_user, internal_ip, external_ip, details FROM {DEVICE_TABLE}"
+        )
         rows = cur.fetchall()
 
         # Build device -> site mapping
@@ -3005,19 +3308,18 @@ def _load_device_records(limit: int = 0):
         site_map = {}
 
     out = []
-    for hostname, description, details_json in rows:
-        d = {}
+    for hostname, description, last_user, internal_ip, external_ip, details_json in rows:
+        summary = {}
         try:
-            d = json.loads(details_json or "{}")
+            summary = (json.loads(details_json or "{}") or {}).get("summary") or {}
         except Exception:
-            d = {}
-        summary = d.get("summary") or {}
+            summary = {}
         rec = {
             "hostname": hostname or summary.get("hostname") or "",
             "description": (description or summary.get("description") or ""),
-            "last_user": summary.get("last_user") or summary.get("last_user_name") or "",
-            "internal_ip": summary.get("internal_ip") or "",
-            "external_ip": summary.get("external_ip") or "",
+            "last_user": last_user or summary.get("last_user") or summary.get("last_user_name") or "",
+            "internal_ip": internal_ip or summary.get("internal_ip") or "",
+            "external_ip": external_ip or summary.get("external_ip") or "",
         }
         site_info = site_map.get(rec["hostname"]) or {}
         rec.update({
@@ -3120,6 +3422,138 @@ def search_suggest():
     })
 
 
+@app.route("/api/devices", methods=["GET"])
+def list_devices():
+    """Return all devices with expanded columns for the WebUI."""
+    try:
+        conn = _db_conn()
+        cur = conn.cursor()
+        cur.execute(
+            f"""
+            SELECT d.hostname, d.description, d.details, d.created_at, d.agent_hash, d.guid,
+                   d.memory, d.network, d.software, d.storage, d.cpu,
+                   d.device_type, d.domain, d.external_ip, d.internal_ip,
+                   d.last_reboot, d.last_seen, d.last_user, d.operating_system,
+                   d.uptime, d.agent_id,
+                   s.id, s.name, s.description
+            FROM {DEVICE_TABLE} d
+            LEFT JOIN device_sites ds ON ds.device_hostname = d.hostname
+            LEFT JOIN sites s ON s.id = ds.site_id
+            """
+        )
+        rows = cur.fetchall()
+        conn.close()
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500
+
+    def _parse_json_list(raw: Optional[str]) -> list:
+        try:
+            return json.loads(raw or "[]")
+        except Exception:
+            return []
+
+    def _parse_json_obj(raw: Optional[str]) -> dict:
+        try:
+            return json.loads(raw or "{}")
+        except Exception:
+            return {}
+
+    def _ts_to_iso(ts: Optional[int]) -> str:
+        if not ts:
+            return ""
+        try:
+            from datetime import datetime, timezone
+
+            return datetime.fromtimestamp(int(ts), timezone.utc).isoformat()
+        except Exception:
+            return ""
+
+    devices = []
+    now = time.time()
+    for row in rows:
+        (
+            hostname,
+            description,
+            details_json,
+            created_at,
+            agent_hash,
+            guid,
+            memory_json,
+            network_json,
+            software_json,
+            storage_json,
+            cpu_json,
+            device_type,
+            domain,
+            external_ip,
+            internal_ip,
+            last_reboot,
+            last_seen,
+            last_user,
+            operating_system,
+            uptime,
+            agent_id,
+            site_id,
+            site_name,
+            site_description,
+        ) = row
+        try:
+            details = json.loads(details_json or "{}")
+        except Exception:
+            details = {}
+        summary = details.get("summary") or {}
+        if description:
+            summary.setdefault("description", description)
+        if agent_hash:
+            summary.setdefault("agent_hash", agent_hash)
+        normalized_guid = _normalize_guid(guid) if guid else ""
+        if normalized_guid:
+            summary.setdefault("agent_guid", normalized_guid)
+        status = "Offline"
+        try:
+            if last_seen and (now - float(last_seen)) <= 300:
+                status = "Online"
+        except Exception:
+            pass
+        devices.append(
+            {
+                "hostname": hostname or summary.get("hostname") or "",
+                "description": description or summary.get("description") or "",
+                "details": details,
+                "summary": summary,
+                "created_at": int(created_at or 0),
+                "created_at_iso": _ts_to_iso(created_at),
+                "agent_hash": (agent_hash or "").strip() if agent_hash else summary.get("agent_hash", ""),
+                "agent_guid": normalized_guid,
+                "memory": _parse_json_list(memory_json),
+                "network": _parse_json_list(network_json),
+                "software": _parse_json_list(software_json),
+                "storage": _parse_json_list(storage_json),
+                "cpu": _parse_json_obj(cpu_json),
+                "device_type": (device_type or "").strip() or summary.get("device_type") or "",
+                "domain": (domain or "").strip(),
+                "external_ip": (external_ip or "").strip() or summary.get("external_ip") or "",
+                "internal_ip": (internal_ip or "").strip() or summary.get("internal_ip") or "",
+                "last_reboot": (last_reboot or "").strip() or summary.get("last_reboot") or "",
+                "last_seen": int(last_seen or 0),
+                "last_seen_iso": _ts_to_iso(last_seen),
+                "last_user": (last_user or "").strip() or summary.get("last_user") or "",
+                "operating_system": (operating_system or "").strip()
+                or summary.get("operating_system")
+                or summary.get("agent_operating_system")
+                or "",
+                "uptime": int(uptime or 0),
+                "agent_id": (agent_id or "").strip() or summary.get("agent_id") or "",
+                "site_id": site_id,
+                "site_name": site_name or "",
+                "site_description": site_description or "",
+                "status": status,
+            }
+        )
+
+    return jsonify({"devices": devices})
+
+
 # ---------------------------------------------
 # Device List Views API
 # ---------------------------------------------
@@ -3277,7 +3711,7 @@ def delete_device_list_view(view_id: int):
 
 
 def _persist_last_seen(hostname: str, last_seen: int, agent_id: str = None):
-    """Persist last_seen (and agent_id if provided) into device_details.details JSON.
+    """Persist last_seen (and agent_id if provided) into the stored device record.
 
     Ensures that after a server restart, we can restore last_seen from DB even
     if the agent is offline, and helps merge entries by keeping track of the
@@ -3289,7 +3723,7 @@ def _persist_last_seen(hostname: str, last_seen: int, agent_id: str = None):
         conn = _db_conn()
         cur = conn.cursor()
         cur.execute(
-            "SELECT details, description, created_at, guid FROM device_details WHERE hostname = ?",
+            f"SELECT details, description, created_at, guid, agent_hash FROM {DEVICE_TABLE} WHERE hostname = ?",
             (hostname,),
         )
         row = cur.fetchone()
@@ -3304,6 +3738,7 @@ def _persist_last_seen(hostname: str, last_seen: int, agent_id: str = None):
             details = {}
             description = ""
             created_at = 0
+        existing_hash = row[4] if row and len(row) > 4 else None
 
         summary = details.get("summary") or {}
         summary["hostname"] = summary.get("hostname") or hostname
@@ -3335,16 +3770,16 @@ def _persist_last_seen(hostname: str, last_seen: int, agent_id: str = None):
             pass
 
         # Single upsert to avoid unique-constraint races
-        cur.execute(
-            """
-            INSERT INTO device_details(hostname, description, details, created_at)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(hostname) DO UPDATE SET
-                description=excluded.description,
-                details=excluded.details,
-                created_at=COALESCE(device_details.created_at, excluded.created_at)
-            """,
-            (hostname, description, json.dumps(details), target_created_at),
+        effective_hash = summary.get("agent_hash") or existing_hash
+        effective_guid = summary.get("agent_guid") or existing_guid
+        _device_upsert(
+            cur,
+            hostname,
+            description,
+            details,
+            target_created_at,
+            agent_hash=effective_hash,
+            guid=effective_guid,
         )
         conn.commit()
         conn.close()
@@ -3357,9 +3792,11 @@ def load_agents_from_db():
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        cur.execute("SELECT hostname, details, agent_hash, guid FROM device_details")
+        cur.execute(
+            f"SELECT hostname, description, details, created_at, agent_hash, guid FROM {DEVICE_TABLE}"
+        )
         rows = cur.fetchall()
-        for hostname, details_json, agent_hash, guid in rows:
+        for hostname, description, details_json, created_at, agent_hash, guid in rows:
             try:
                 details = json.loads(details_json or "{}")
             except Exception:
@@ -3373,11 +3810,17 @@ def load_agents_from_db():
                 stored_hash = summary.get("agent_hash") or ""
             agent_guid = (summary.get("agent_guid") or guid or "").strip()
             if guid and not summary.get("agent_guid"):
-                summary["agent_guid"] = _normalize_guid(guid)
+                normalized_guid = _normalize_guid(guid)
+                summary["agent_guid"] = normalized_guid
                 try:
-                    cur.execute(
-                        "UPDATE device_details SET details=? WHERE hostname=?",
-                        (json.dumps(details), hostname),
+                    _device_upsert(
+                        cur,
+                        hostname,
+                        description,
+                        details,
+                        created_at,
+                        agent_hash=agent_hash or stored_hash,
+                        guid=normalized_guid,
                     )
                 except Exception:
                     pass
@@ -3428,7 +3871,7 @@ def _device_rows_for_agent(cur, agent_id: str) -> List[Dict[str, Any]]:
         return results
     try:
         cur.execute(
-            "SELECT hostname, agent_hash, details, guid FROM device_details WHERE LOWER(hostname) = ?",
+            f"SELECT hostname, agent_hash, details, guid FROM {DEVICE_TABLE} WHERE LOWER(hostname) = ?",
             (base_host.lower(),),
         )
         rows = cur.fetchall()
@@ -3470,14 +3913,22 @@ def _ensure_agent_guid_for_hostname(cur, hostname: str, agent_id: Optional[str]
     if not normalized_host:
         return None
     cur.execute(
-        "SELECT hostname, guid, details FROM device_details WHERE LOWER(hostname) = ?",
+        f"SELECT hostname, guid, details, description, created_at, agent_hash FROM {DEVICE_TABLE} WHERE LOWER(hostname) = ?",
         (normalized_host.lower(),),
     )
     row = cur.fetchone()
     if row:
-        actual_host, existing_guid, details_json = row
+        actual_host = row[0]
+        existing_guid = row[1] or ""
+        details_json = row[2] or "{}"
+        description = row[3] if len(row) > 3 else ""
+        created_at = row[4] if len(row) > 4 else None
+        agent_hash = row[5] if len(row) > 5 else None
     else:
         actual_host, existing_guid, details_json = normalized_host, "", "{}"
+        description = ""
+        created_at = None
+        agent_hash = None
     try:
         details = json.loads(details_json or "{}")
     except Exception:
@@ -3494,26 +3945,28 @@ def _ensure_agent_guid_for_hostname(cur, hostname: str, agent_id: Optional[str]
     if existing_guid:
         normalized = _normalize_guid(existing_guid)
         summary.setdefault("agent_guid", normalized)
-        cur.execute(
-            "UPDATE device_details SET guid=?, details=? WHERE hostname=?",
-            (normalized, json.dumps(details), actual_host),
+        _device_upsert(
+            cur,
+            actual_host,
+            description,
+            details,
+            created_at,
+            agent_hash=agent_hash,
+            guid=normalized,
         )
         return summary.get("agent_guid") or normalized
 
     new_guid = str(uuid.uuid4())
     summary["agent_guid"] = new_guid
     now = int(time.time())
-    cur.execute(
-        """
-        INSERT INTO device_details(hostname, description, details, created_at, guid)
-        VALUES (?, COALESCE((SELECT description FROM device_details WHERE hostname = ?), ''), ?, COALESCE((SELECT created_at FROM device_details WHERE hostname = ?), ?), ?)
-        ON CONFLICT(hostname) DO UPDATE SET
-            guid=excluded.guid,
-            details=excluded.details,
-            created_at=COALESCE(device_details.created_at, excluded.created_at),
-            description=COALESCE(device_details.description, excluded.description)
-        """,
-        (actual_host, actual_host, json.dumps(details), actual_host, now, new_guid),
+    _device_upsert(
+        cur,
+        actual_host,
+        description,
+        details,
+        created_at or now,
+        agent_hash=agent_hash,
+        guid=new_guid,
     )
     return new_guid
 
@@ -3531,9 +3984,23 @@ def _ensure_agent_guid(agent_id: str, hostname: Optional[str] = None) -> Optiona
             if candidate:
                 summary = row.get("details", {}).setdefault("summary", {})
                 summary.setdefault("agent_guid", candidate)
+                host = row.get("hostname")
                 cur.execute(
-                    "UPDATE device_details SET guid=?, details=? WHERE hostname=?",
-                    (candidate, json.dumps(row.get("details", {})), row.get("hostname")),
+                    f"SELECT description, created_at, agent_hash FROM {DEVICE_TABLE} WHERE hostname = ?",
+                    (host,),
+                )
+                info = cur.fetchone()
+                description = info[0] if info else None
+                created_at = info[1] if info else None
+                agent_hash = info[2] if info else None
+                _device_upsert(
+                    cur,
+                    host,
+                    description,
+                    row.get("details", {}),
+                    created_at,
+                    agent_hash=agent_hash,
+                    guid=candidate,
                 )
                 conn.commit()
                 return candidate
@@ -3641,7 +4108,7 @@ def save_agent_details():
         cur = conn.cursor()
         # Load existing row to preserve description and created_at and merge fields
         cur.execute(
-            "SELECT details, description, created_at, guid FROM device_details WHERE hostname = ?",
+            f"SELECT details, description, created_at, guid, agent_hash FROM {DEVICE_TABLE} WHERE hostname = ?",
             (hostname,),
         )
         row = cur.fetchone()
@@ -3649,6 +4116,7 @@ def save_agent_details():
         description = ""
         created_at = 0
         existing_guid = None
+        existing_agent_hash = None
         if row:
             try:
                 prev_details = json.loads(row[0] or '{}')
@@ -3663,6 +4131,10 @@ def save_agent_details():
                 existing_guid = (row[3] or "").strip()
             except Exception:
                 existing_guid = None
+            try:
+                existing_agent_hash = (row[4] or "").strip()
+            except Exception:
+                existing_agent_hash = None
         else:
             existing_guid = None
 
@@ -3737,25 +4209,14 @@ def save_agent_details():
             pass
 
         # Upsert row without destroying created_at; keep previous created_at if exists
-        cur.execute(
-            """
-            INSERT INTO device_details(hostname, description, details, created_at, agent_hash, guid)
-            VALUES (?,?,?,?,?,?)
-            ON CONFLICT(hostname) DO UPDATE SET
-                description=excluded.description,
-                details=excluded.details,
-                created_at=COALESCE(device_details.created_at, excluded.created_at),
-                agent_hash=COALESCE(NULLIF(excluded.agent_hash, ''), device_details.agent_hash),
-                guid=COALESCE(NULLIF(excluded.guid, ''), device_details.guid)
-            """,
-            (
-                hostname,
-                description,
-                json.dumps(merged),
-                created_at,
-                agent_hash or None,
-                (normalized_effective_guid or None),
-            ),
+        _device_upsert(
+            cur,
+            hostname,
+            description,
+            merged,
+            created_at,
+            agent_hash=agent_hash or existing_agent_hash,
+            guid=normalized_effective_guid,
         )
         conn.commit()
         conn.close()
@@ -3790,7 +4251,15 @@ def get_device_details(hostname: str):
         conn = _db_conn()
         cur = conn.cursor()
         cur.execute(
-            "SELECT details, description, created_at, agent_hash, guid FROM device_details WHERE hostname = ?",
+            f"""
+            SELECT details, description, created_at, agent_hash, guid,
+                   memory, network, software, storage, cpu,
+                   device_type, domain, external_ip, internal_ip,
+                   last_reboot, last_seen, last_user, operating_system,
+                   uptime, agent_id
+            FROM {DEVICE_TABLE}
+            WHERE hostname = ?
+            """,
             (hostname,),
         )
         row = cur.fetchone()
@@ -3819,16 +4288,48 @@ def get_device_details(hostname: str):
                         details['summary']['agent_hash'] = agent_hash
                 except Exception:
                     pass
-            if len(row) > 4:
-                agent_guid = (row[4] or "").strip()
-                if agent_guid:
-                    try:
-                        details.setdefault('summary', {})
-                        if not details['summary'].get('agent_guid'):
-                            details['summary']['agent_guid'] = _normalize_guid(agent_guid)
-                    except Exception:
-                        pass
-            return jsonify(details)
+            agent_guid = (row[4] or "").strip() if len(row) > 4 else ""
+            normalized_guid = _normalize_guid(agent_guid) if agent_guid else ""
+            if normalized_guid:
+                details.setdefault('summary', {})
+                details['summary'].setdefault('agent_guid', normalized_guid)
+
+            def _parse_list(raw: Optional[str]) -> list:
+                try:
+                    return json.loads(raw or '[]')
+                except Exception:
+                    return []
+
+            def _parse_obj(raw: Optional[str]) -> dict:
+                try:
+                    return json.loads(raw or '{}')
+                except Exception:
+                    return {}
+
+            payload = {
+                "details": details,
+                "summary": details.get("summary", {}),
+                "description": description or "",
+                "created_at": created_at,
+                "agent_hash": agent_hash,
+                "agent_guid": normalized_guid,
+                "memory": _parse_list(row[5] if len(row) > 5 else None),
+                "network": _parse_list(row[6] if len(row) > 6 else None),
+                "software": _parse_list(row[7] if len(row) > 7 else None),
+                "storage": _parse_list(row[8] if len(row) > 8 else None),
+                "cpu": _parse_obj(row[9] if len(row) > 9 else None),
+                "device_type": (row[10] or "").strip() if len(row) > 10 and row[10] else "",
+                "domain": (row[11] or "").strip() if len(row) > 11 and row[11] else "",
+                "external_ip": (row[12] or "").strip() if len(row) > 12 and row[12] else "",
+                "internal_ip": (row[13] or "").strip() if len(row) > 13 and row[13] else "",
+                "last_reboot": (row[14] or "").strip() if len(row) > 14 and row[14] else "",
+                "last_seen": int(row[15] or 0) if len(row) > 15 and row[15] is not None else 0,
+                "last_user": (row[16] or "").strip() if len(row) > 16 and row[16] else "",
+                "operating_system": (row[17] or "").strip() if len(row) > 17 and row[17] else "",
+                "uptime": int(row[18] or 0) if len(row) > 18 and row[18] is not None else 0,
+                "agent_id": (row[19] or "").strip() if len(row) > 19 and row[19] else "",
+            }
+            return jsonify(payload)
     except Exception:
         pass
     return jsonify({})
@@ -3841,17 +4342,34 @@ def set_device_description(hostname: str):
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        now = int(time.time())
-        # Insert row if missing with created_at; otherwise update description only
         cur.execute(
-            "INSERT INTO device_details(hostname, description, details, created_at) "
-            "VALUES (?, COALESCE(?, ''), COALESCE((SELECT details FROM device_details WHERE hostname = ?), '{}'), ?) "
-            "ON CONFLICT(hostname) DO NOTHING",
-            (hostname, description, hostname, now),
+            f"SELECT details, created_at, agent_hash, guid, description FROM {DEVICE_TABLE} WHERE hostname = ?",
+            (hostname,),
         )
-        cur.execute(
-            "UPDATE device_details SET description=? WHERE hostname=?",
-            (description, hostname),
+        row = cur.fetchone()
+        if row:
+            details_json, created_at, agent_hash, guid, existing_description = row
+            try:
+                details = json.loads(details_json or "{}")
+            except Exception:
+                details = {}
+            created_at = created_at or int(time.time())
+        else:
+            details = {}
+            created_at = int(time.time())
+            agent_hash = None
+            guid = None
+            existing_description = ""
+        summary = details.setdefault("summary", {})
+        summary["description"] = description
+        _device_upsert(
+            cur,
+            hostname,
+            description or existing_description or "",
+            details,
+            created_at,
+            agent_hash=agent_hash,
+            guid=guid,
         )
         conn.commit()
         conn.close()
@@ -4876,7 +5394,7 @@ def handle_collector_status(data):
             conn = _db_conn()
             cur = conn.cursor()
             cur.execute(
-                "SELECT details, description, created_at FROM device_details WHERE hostname = ?",
+                f"SELECT details, description, created_at, agent_hash, guid FROM {DEVICE_TABLE} WHERE hostname = ?",
                 (host,),
             )
             row = cur.fetchone()
@@ -4887,25 +5405,27 @@ def handle_collector_status(data):
                     details = {}
                 description = row[1] or ""
                 created_at = int(row[2] or 0)
+                existing_hash = (row[3] or "").strip() if len(row) > 3 else None
+                existing_guid = (row[4] or "").strip() if len(row) > 4 else None
             else:
                 details = {}
                 description = ""
                 created_at = 0
+                existing_hash = None
+                existing_guid = None
             summary = details.get('summary') or {}
             # Only update last_user if provided; do not clear other fields
             summary['last_user'] = last_user
             details['summary'] = summary
             now = int(time.time())
-            cur.execute(
-                """
-                INSERT INTO device_details(hostname, description, details, created_at)
-                VALUES (?,?,?,?)
-                ON CONFLICT(hostname) DO UPDATE SET
-                    description=excluded.description,
-                    details=excluded.details,
-                    created_at=COALESCE(device_details.created_at, excluded.created_at)
-                """,
-                (host, description, json.dumps(details), created_at or now),
+            _device_upsert(
+                cur,
+                host,
+                description,
+                details,
+                created_at or now,
+                agent_hash=existing_hash,
+                guid=existing_guid,
             )
             conn.commit()
             conn.close()
@@ -4918,10 +5438,10 @@ def delete_agent(agent_id: str):
     """Remove an agent from the registry and database."""
     info = registered_agents.pop(agent_id, None)
     agent_configurations.pop(agent_id, None)
-    # IMPORTANT: Do NOT delete device_details here. Multiple in-memory agent
+    # IMPORTANT: Do NOT delete devices here. Multiple in-memory agent
     # records can refer to the same hostname; removing one should not wipe the
     # persisted device inventory for the hostname. A dedicated endpoint can be
-    # added later to purge device_details by hostname if needed.
+    # added later to purge devices by hostname if needed.
     if info:
         return jsonify({"status": "removed"})
     return jsonify({"error": "agent not found"}), 404

From 1cb74c48c4864b61b106d27cdd94bdcaf67dcdc9 Mon Sep 17 00:00:00 2001
From: Nicole Rappe <nicole.rappe@bunny-lab.io>
Date: Wed, 8 Oct 2025 21:21:42 -0600
Subject: [PATCH 2/4] Ensure device views use GUID identifiers

---
 .../WebUI/src/Devices/Device_Details.jsx      | 232 +++--
 Data/Server/WebUI/src/Devices/Device_List.jsx |   9 +-
 Data/Server/server.py                         | 883 ++++++++++--------
 3 files changed, 668 insertions(+), 456 deletions(-)

diff --git a/Data/Server/WebUI/src/Devices/Device_Details.jsx b/Data/Server/WebUI/src/Devices/Device_Details.jsx
index 5225bb5d..9eed9e28 100644
--- a/Data/Server/WebUI/src/Devices/Device_Details.jsx
+++ b/Data/Server/WebUI/src/Devices/Device_Details.jsx
@@ -43,6 +43,7 @@ export default function DeviceDetails({ device, onBack }) {
   const [tab, setTab] = useState(0);
   const [agent, setAgent] = useState(device || {});
   const [details, setDetails] = useState({});
+  const [meta, setMeta] = useState({});
   const [softwareOrderBy, setSoftwareOrderBy] = useState("name");
   const [softwareOrder, setSoftwareOrder] = useState("asc");
   const [softwareSearch, setSoftwareSearch] = useState("");
@@ -94,54 +95,137 @@ export default function DeviceDetails({ device, onBack }) {
   };
 
   useEffect(() => {
-    // When navigating to a different device, take a fresh snapshot of its status
     if (device) {
       setLockedStatus(device.status || statusFromHeartbeat(device.lastSeen));
     }
 
-    if (!device || !device.hostname) return;
+    const guid = device?.agent_guid || device?.guid || device?.agentGuid || device?.summary?.agent_guid;
+    const agentId = device?.agentId || device?.summary?.agent_id || device?.id;
+    const hostname = device?.hostname || device?.summary?.hostname;
+    if (!device || (!guid && !hostname)) return;
+
     const load = async () => {
       try {
-        const [agentsRes, detailsRes] = await Promise.all([
-          fetch("/api/agents"),
-          fetch(`/api/device/details/${device.hostname}`)
-        ]);
-        const agentsData = await agentsRes.json();
-        if (agentsData && agentsData[device.id]) {
-          setAgent({ id: device.id, ...agentsData[device.id] });
+        const agentsPromise = fetch("/api/agents").catch(() => null);
+        let detailResponse = null;
+        if (guid) {
+          try {
+            detailResponse = await fetch(`/api/devices/${encodeURIComponent(guid)}`);
+          } catch (err) {
+            detailResponse = null;
+          }
         }
-        const detailData = await detailsRes.json();
-        const summary = detailData?.summary && typeof detailData.summary === 'object'
-          ? detailData.summary
-          : (detailData?.details?.summary || {});
+        if ((!detailResponse || !detailResponse.ok) && hostname) {
+          try {
+            detailResponse = await fetch(`/api/device/details/${encodeURIComponent(hostname)}`);
+          } catch (err) {
+            detailResponse = null;
+          }
+        }
+        if (!detailResponse || !detailResponse.ok) {
+          throw new Error(`Failed to load device record (${detailResponse ? detailResponse.status : 'no response'})`);
+        }
+
+        const [agentsData, detailData] = await Promise.all([
+          agentsPromise?.then((r) => (r ? r.json() : {})).catch(() => ({})),
+          detailResponse.json(),
+        ]);
+
+        if (agentsData && agentId && agentsData[agentId]) {
+          setAgent({ id: agentId, ...agentsData[agentId] });
+        }
+
+        const summary =
+          detailData?.summary && typeof detailData.summary === "object"
+            ? detailData.summary
+            : (detailData?.details?.summary || {});
+        const normalizedSummary = { ...(summary || {}) };
+        if (detailData?.description) {
+          normalizedSummary.description = detailData.description;
+        }
+
         const normalized = {
-          ...(detailData?.details || {}),
-          summary: summary || {},
-          memory: Array.isArray(detailData?.memory) ? detailData.memory : (detailData?.details?.memory || []),
-          network: Array.isArray(detailData?.network) ? detailData.network : (detailData?.details?.network || []),
-          software: Array.isArray(detailData?.software) ? detailData.software : (detailData?.details?.software || []),
-          storage: Array.isArray(detailData?.storage) ? detailData.storage : (detailData?.details?.storage || []),
+          summary: normalizedSummary,
+          memory: Array.isArray(detailData?.memory)
+            ? detailData.memory
+            : Array.isArray(detailData?.details?.memory)
+              ? detailData.details.memory
+              : [],
+          network: Array.isArray(detailData?.network)
+            ? detailData.network
+            : Array.isArray(detailData?.details?.network)
+              ? detailData.details.network
+              : [],
+          software: Array.isArray(detailData?.software)
+            ? detailData.software
+            : Array.isArray(detailData?.details?.software)
+              ? detailData.details.software
+              : [],
+          storage: Array.isArray(detailData?.storage)
+            ? detailData.storage
+            : Array.isArray(detailData?.details?.storage)
+              ? detailData.details.storage
+              : [],
           cpu: detailData?.cpu || detailData?.details?.cpu || {},
         };
-        if (detailData?.description) {
-          normalized.summary = { ...normalized.summary, description: detailData.description };
-        }
         setDetails(normalized);
-        setDescription(normalized.summary?.description || detailData?.description || "");
+
+        const toYmdHms = (dateObj) => {
+          if (!dateObj || Number.isNaN(dateObj.getTime())) return '';
+          const pad = (v) => String(v).padStart(2, '0');
+          return `${dateObj.getUTCFullYear()}-${pad(dateObj.getUTCMonth() + 1)}-${pad(dateObj.getUTCDate())} ${pad(dateObj.getUTCHours())}:${pad(dateObj.getUTCMinutes())}:${pad(dateObj.getUTCSeconds())}`;
+        };
+
+        let createdDisplay = normalizedSummary.created || '';
+        if (!createdDisplay) {
+          if (detailData?.created_at && Number(detailData.created_at)) {
+            createdDisplay = toYmdHms(new Date(Number(detailData.created_at) * 1000));
+          } else if (detailData?.created_at_iso) {
+            createdDisplay = toYmdHms(new Date(detailData.created_at_iso));
+          }
+        }
+
+        const metaPayload = {
+          hostname: detailData?.hostname || normalizedSummary.hostname || hostname || "",
+          lastUser: detailData?.last_user || normalizedSummary.last_user || "",
+          deviceType: detailData?.device_type || normalizedSummary.device_type || "",
+          created: createdDisplay,
+          createdAtIso: detailData?.created_at_iso || "",
+          lastSeen: detailData?.last_seen || normalizedSummary.last_seen || 0,
+          lastReboot: detailData?.last_reboot || normalizedSummary.last_reboot || "",
+          operatingSystem:
+            detailData?.operating_system || normalizedSummary.operating_system || normalizedSummary.agent_operating_system || "",
+          agentId: detailData?.agent_id || normalizedSummary.agent_id || agentId || "",
+          agentGuid: detailData?.agent_guid || normalizedSummary.agent_guid || guid || "",
+          agentHash: detailData?.agent_hash || normalizedSummary.agent_hash || "",
+          internalIp: detailData?.internal_ip || normalizedSummary.internal_ip || "",
+          externalIp: detailData?.external_ip || normalizedSummary.external_ip || "",
+          siteId: detailData?.site_id,
+          siteName: detailData?.site_name || "",
+          siteDescription: detailData?.site_description || "",
+          status: detailData?.status || "",
+        };
+        setMeta(metaPayload);
+        setDescription(normalizedSummary.description || detailData?.description || "");
+
         setAgent((prev) => ({
           ...(prev || {}),
-          id: device?.id || prev?.id,
-          hostname: device?.hostname || normalized.summary?.hostname || prev?.hostname,
-          agent_hash: detailData?.agent_hash || normalized.summary?.agent_hash || prev?.agent_hash,
-          agent_operating_system:
-            detailData?.operating_system ||
-            normalized.summary?.operating_system ||
-            prev?.agent_operating_system,
-          device_type: detailData?.device_type || normalized.summary?.device_type || prev?.device_type,
-          last_seen: detailData?.last_seen || normalized.summary?.last_seen || prev?.last_seen,
+          id: agentId || prev?.id,
+          hostname: metaPayload.hostname || prev?.hostname,
+          agent_hash: metaPayload.agentHash || prev?.agent_hash,
+          agent_operating_system: metaPayload.operatingSystem || prev?.agent_operating_system,
+          device_type: metaPayload.deviceType || prev?.device_type,
+          last_seen: metaPayload.lastSeen || prev?.last_seen,
         }));
+
+        if (metaPayload.status) {
+          setLockedStatus(metaPayload.status);
+        } else if (metaPayload.lastSeen) {
+          setLockedStatus(statusFromHeartbeat(metaPayload.lastSeen));
+        }
       } catch (e) {
         console.warn("Failed to load device info", e);
+        setMeta({});
       }
     };
     load();
@@ -178,9 +262,10 @@ export default function DeviceDetails({ device, onBack }) {
   };
 
   const saveDescription = async () => {
-    if (!details.summary?.hostname) return;
+    const targetHost = meta.hostname || details.summary?.hostname;
+    if (!targetHost) return;
     try {
-      await fetch(`/api/device/description/${details.summary.hostname}`, {
+      await fetch(`/api/device/description/${targetHost}`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ description })
@@ -189,6 +274,7 @@ export default function DeviceDetails({ device, onBack }) {
         ...d,
         summary: { ...(d.summary || {}), description }
       }));
+      setMeta((m) => ({ ...(m || {}), hostname: targetHost }));
     } catch (e) {
       console.warn("Failed to save description", e);
     }
@@ -263,7 +349,7 @@ export default function DeviceDetails({ device, onBack }) {
   const summary = details.summary || {};
   // Build a best-effort CPU display from summary fields
   const cpuInfo = useMemo(() => {
-    const cpu = summary.cpu || {};
+    const cpu = details.cpu || summary.cpu || {};
     const cores = cpu.logical_cores || cpu.cores || cpu.physical_cores;
     let ghz = cpu.base_clock_ghz;
     if (!ghz && typeof (summary.processor || '') === 'string') {
@@ -280,24 +366,42 @@ export default function DeviceDetails({ device, onBack }) {
   }, [summary]);
 
   const summaryItems = [
-    { label: "Hostname", value: summary.hostname || agent.hostname || device?.hostname || "unknown" },
-    { label: "Operating System", value: summary.operating_system || agent.agent_operating_system || "unknown" },
-    { label: "Processor", value: cpuInfo.display || "unknown" },
-    { label: "Device Type", value: summary.device_type || "unknown" },
-    { label: "Last User", value: (
-      <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
-        <Box component="span" sx={{
-          display: 'inline-block', width: 10, height: 10, borderRadius: 10,
-          bgcolor: agent?.collector_active ? '#00d18c' : '#ff4f4f'
-        }} />
-        <span>{summary.last_user || 'unknown'}</span>
-      </Box>
-    ) },
-    { label: "Internal IP", value: summary.internal_ip || "unknown" },
-    { label: "External IP", value: summary.external_ip || "unknown" },
-    { label: "Last Reboot", value: summary.last_reboot ? formatDateTime(summary.last_reboot) : "unknown" },
-    { label: "Created", value: summary.created ? formatDateTime(summary.created) : "unknown" },
-    { label: "Last Seen", value: formatLastSeen(agent.last_seen || device?.lastSeen) }
+    { label: "Hostname", value: meta.hostname || summary.hostname || agent.hostname || device?.hostname || "unknown" },
+    {
+      label: "Last User",
+      value: (
+        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
+          <Box
+            component="span"
+            sx={{
+              display: 'inline-block',
+              width: 10,
+              height: 10,
+              borderRadius: 10,
+              bgcolor: agent?.collector_active ? '#00d18c' : '#ff4f4f'
+            }}
+          />
+          <span>{meta.lastUser || summary.last_user || 'unknown'}</span>
+        </Box>
+      )
+    },
+    { label: "Device Type", value: meta.deviceType || summary.device_type || 'unknown' },
+    {
+      label: "Created",
+      value: meta.created ? formatDateTime(meta.created) : summary.created ? formatDateTime(summary.created) : 'unknown'
+    },
+    {
+      label: "Last Seen",
+      value: formatLastSeen(meta.lastSeen || agent.last_seen || device?.lastSeen)
+    },
+    {
+      label: "Last Reboot",
+      value: meta.lastReboot ? formatDateTime(meta.lastReboot) : summary.last_reboot ? formatDateTime(summary.last_reboot) : 'unknown'
+    },
+    { label: "Operating System", value: meta.operatingSystem || summary.operating_system || agent.agent_operating_system || 'unknown' },
+    { label: "Agent ID", value: meta.agentId || summary.agent_id || 'unknown' },
+    { label: "Agent GUID", value: meta.agentGuid || summary.agent_guid || 'unknown' },
+    { label: "Agent Hash", value: meta.agentHash || summary.agent_hash || 'unknown' },
   ];
 
   const MetricCard = ({ icon, title, main, sub, color }) => {
@@ -720,9 +824,29 @@ export default function DeviceDetails({ device, onBack }) {
 
   const renderNetwork = () => {
     const rows = details.network || [];
-    if (!rows.length) return placeholderTable(["Adapter", "IP Address", "MAC Address"]);
+    const internalIp = meta.internalIp || summary.internal_ip || "unknown";
+    const externalIp = meta.externalIp || summary.external_ip || "unknown";
+    const ipHeader = (
+      <Box sx={{ mb: rows.length ? 1.5 : 1 }}>
+        <Typography variant="body2" sx={{ display: 'block', opacity: 0.9 }}>
+          Internal IP: {internalIp || 'unknown'}
+        </Typography>
+        <Typography variant="body2" sx={{ display: 'block', opacity: 0.9 }}>
+          External IP: {externalIp || 'unknown'}
+        </Typography>
+      </Box>
+    );
+    if (!rows.length) {
+      return (
+        <Box>
+          {ipHeader}
+          {placeholderTable(["Adapter", "IP Address", "MAC Address"])}
+        </Box>
+      );
+    }
     return (
       <Box>
+        {ipHeader}
         <Table size="small">
           <TableHead>
             <TableRow>
diff --git a/Data/Server/WebUI/src/Devices/Device_List.jsx b/Data/Server/WebUI/src/Devices/Device_List.jsx
index 8e90c3e3..52531ef1 100644
--- a/Data/Server/WebUI/src/Devices/Device_List.jsx
+++ b/Data/Server/WebUI/src/Devices/Device_List.jsx
@@ -240,9 +240,9 @@ export default function DeviceList({ onSelectDevice }) {
         const rawHostname = (device.hostname || summary.hostname || '').trim();
         const hostname = rawHostname || `device-${index + 1}`;
         const agentId = (device.agent_id || summary.agent_id || '').trim();
-        const id = agentId || hostname || `device-${index + 1}`;
         const guidRaw = (device.agent_guid || summary.agent_guid || '').trim();
         const guidLookupKey = guidRaw.toLowerCase();
+        const rowKey = guidRaw || agentId || hostname || `device-${index + 1}`;
         let agentHash = (device.agent_hash || summary.agent_hash || '').trim();
         if (agentId && hashById.has(agentId)) agentHash = hashById.get(agentId) || agentHash;
         if (!agentHash && guidLookupKey && hashByGuid.has(guidLookupKey)) {
@@ -305,7 +305,7 @@ export default function DeviceList({ onSelectDevice }) {
         const cpuDisplay = cpuObj.name || summary.processor || '';
 
         return {
-          id,
+          id: rowKey,
           hostname,
           status,
           lastSeen,
@@ -551,8 +551,11 @@ export default function DeviceList({ onSelectDevice }) {
 
   const handleDelete = async () => {
     if (!selected) return;
+    const targetAgentId = selected.agentId || selected.summary?.agent_id || selected.id;
     try {
-      await fetch(`/api/agent/${selected.id}`, { method: "DELETE" });
+      if (targetAgentId) {
+        await fetch(`/api/agent/${encodeURIComponent(targetAgentId)}`, { method: "DELETE" });
+      }
     } catch (e) {
       console.warn("Failed to remove agent", e);
     }
diff --git a/Data/Server/server.py b/Data/Server/server.py
index a2f7e150..6a424eb0 100644
--- a/Data/Server/server.py
+++ b/Data/Server/server.py
@@ -17,7 +17,7 @@ import time
 import os  # To Read Production ReactJS Server Folder
 import json  # For reading workflow JSON files
 import shutil  # For moving workflow files and folders
-from typing import List, Dict, Tuple, Optional, Any, Set
+from typing import List, Dict, Tuple, Optional, Any, Set, Sequence
 import sqlite3
 import io
 import uuid
@@ -463,26 +463,25 @@ def _lookup_agent_hash_record(agent_id: str) -> Optional[Dict[str, Any]]:
                 if row_guid:
                     payload['agent_guid'] = row_guid
                 return payload
-        cur.execute(f'SELECT hostname, agent_hash, details, guid FROM {DEVICE_TABLE}')
-        for host, db_hash, details_json, row_guid in cur.fetchall():
-            try:
-                data = json.loads(details_json or '{}')
-            except Exception:
-                data = {}
-            summary = data.get('summary') or {}
+        cur.execute(f'SELECT {_device_column_sql()} FROM {DEVICE_TABLE}')
+        for row in cur.fetchall():
+            record = _row_to_device_dict(row, _DEVICE_TABLE_COLUMNS)
+            snapshot = _assemble_device_snapshot(record)
+            summary = snapshot.get('summary', {})
             summary_agent_id = (summary.get('agent_id') or '').strip()
             if summary_agent_id != agent_id:
                 continue
-            summary_hash = (summary.get('agent_hash') or '').strip()
-            normalized_hash = (db_hash or '').strip() or summary_hash
+            normalized_hash = (snapshot.get('agent_hash') or '').strip()
+            if not normalized_hash:
+                normalized_hash = (summary.get('agent_hash') or '').strip()
             if normalized_hash:
                 payload = {
                     'agent_id': agent_id,
                     'agent_hash': normalized_hash,
-                    'hostname': host,
+                    'hostname': snapshot.get('hostname'),
                     'source': 'database',
                 }
-                normalized_guid = _normalize_guid(row_guid) if row_guid else ''
+                normalized_guid = snapshot.get('agent_guid') or ''
                 if not normalized_guid:
                     normalized_guid = _normalize_guid(summary.get('agent_guid')) if summary.get('agent_guid') else ''
                 if normalized_guid:
@@ -528,24 +527,21 @@ def _lookup_agent_hash_by_guid(agent_guid: str) -> Optional[Dict[str, Any]]:
         conn = _db_conn()
         cur = conn.cursor()
         cur.execute(
-            f'SELECT hostname, agent_hash, details FROM {DEVICE_TABLE} WHERE guid = ?',
-            (normalized_guid,),
+            f'SELECT {_device_column_sql()} FROM {DEVICE_TABLE} WHERE LOWER(guid) = ?',
+            (normalized_guid.lower(),),
         )
         row = cur.fetchone()
         if not row:
             return None
-        hostname, agent_hash, details_json = row
-        try:
-            details = json.loads(details_json or '{}')
-        except Exception:
-            details = {}
-        summary = details.get('summary') or {}
+        record = _row_to_device_dict(row, _DEVICE_TABLE_COLUMNS)
+        snapshot = _assemble_device_snapshot(record)
+        summary = snapshot.get('summary', {})
         agent_id = (summary.get('agent_id') or '').strip()
-        normalized_hash = (agent_hash or summary.get('agent_hash') or '').strip()
+        normalized_hash = (snapshot.get('agent_hash') or summary.get('agent_hash') or '').strip()
         payload = {
             'agent_guid': normalized_guid,
             'agent_hash': normalized_hash,
-            'hostname': hostname,
+            'hostname': snapshot.get('hostname'),
             'source': 'database',
         }
         if agent_id:
@@ -638,21 +634,19 @@ def _collect_agent_hash_records() -> List[Dict[str, Any]]:
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        cur.execute(f'SELECT hostname, agent_hash, details, guid FROM {DEVICE_TABLE}')
-        for hostname, stored_hash, details_json, row_guid in cur.fetchall():
-            try:
-                details = json.loads(details_json or '{}')
-            except Exception:
-                details = {}
-            summary = details.get('summary') or {}
+        cur.execute(f'SELECT {_device_column_sql()} FROM {DEVICE_TABLE}')
+        for row in cur.fetchall():
+            record = _row_to_device_dict(row, _DEVICE_TABLE_COLUMNS)
+            snapshot = _assemble_device_snapshot(record)
+            summary = snapshot.get('summary', {})
             summary_hash = (summary.get('agent_hash') or '').strip()
-            summary_guid = summary.get('agent_guid') or ''
+            summary_guid = summary.get('agent_guid') or snapshot.get('agent_guid') or ''
             summary_agent_id = (summary.get('agent_id') or '').strip()
-            normalized_hash = (stored_hash or '').strip() or summary_hash
+            normalized_hash = (snapshot.get('agent_hash') or '').strip() or summary_hash
             _register(
                 summary_agent_id or None,
-                summary_guid or row_guid,
-                hostname,
+                summary_guid or snapshot.get('agent_guid'),
+                snapshot.get('hostname'),
                 normalized_hash,
                 'database',
             )
@@ -719,18 +713,17 @@ def _apply_agent_hash_update(agent_id: str, agent_hash: str, agent_guid: Optiona
         updated_via_guid = False
         if normalized_guid:
             cur.execute(
-                f'SELECT hostname, description, details, created_at, agent_hash FROM {DEVICE_TABLE} WHERE guid = ?',
-                (normalized_guid,),
+                f'SELECT {_device_column_sql()} FROM {DEVICE_TABLE} WHERE LOWER(guid) = ?',
+                (normalized_guid.lower(),),
             )
             row = cur.fetchone()
             if row:
                 updated_via_guid = True
-                hostname = row[0]
-                description = row[1]
-                try:
-                    details = json.loads(row[2] or '{}')
-                except Exception:
-                    details = {}
+                record = _row_to_device_dict(row, _DEVICE_TABLE_COLUMNS)
+                snapshot = _assemble_device_snapshot(record)
+                hostname = snapshot.get('hostname')
+                description = snapshot.get('description')
+                details = snapshot.get('details', {})
                 summary = details.setdefault('summary', {})
                 if not resolved_agent_id:
                     resolved_agent_id = (summary.get('agent_id') or '').strip()
@@ -738,8 +731,8 @@ def _apply_agent_hash_update(agent_id: str, agent_hash: str, agent_guid: Optiona
                     summary['agent_id'] = resolved_agent_id
                 summary['agent_hash'] = agent_hash
                 summary['agent_guid'] = normalized_guid
-                existing_created_at = row[3] if len(row) > 3 else None
-                existing_hash = row[4] if len(row) > 4 else None
+                existing_created_at = snapshot.get('created_at')
+                existing_hash = snapshot.get('agent_hash')
                 _device_upsert(
                     cur,
                     hostname,
@@ -781,14 +774,10 @@ def _apply_agent_hash_update(agent_id: str, agent_hash: str, agent_guid: Optiona
                     summary['agent_guid'] = normalized_guid
                 if resolved_agent_id:
                     summary['agent_id'] = resolved_agent_id
-                cur.execute(
-                    f'SELECT description, created_at, agent_hash FROM {DEVICE_TABLE} WHERE hostname = ?',
-                    (hostname,),
-                )
-                info_row = cur.fetchone()
-                description = info_row[0] if info_row else None
-                existing_created_at = info_row[1] if info_row else None
-                existing_hash = info_row[2] if info_row else None
+                snapshot_existing = _load_device_snapshot(cur, hostname=hostname)
+                description = snapshot_existing.get('description') if snapshot_existing else None
+                existing_created_at = snapshot_existing.get('created_at') if snapshot_existing else None
+                existing_hash = snapshot_existing.get('agent_hash') if snapshot_existing else None
                 effective_guid = normalized_guid or target.get('guid')
                 _device_upsert(
                     cur,
@@ -2462,6 +2451,181 @@ _DEVICE_JSON_OBJECT_FIELDS = {
 }
 
 
+_DEVICE_TABLE_COLUMNS = [
+    "hostname",
+    "description",
+    "created_at",
+    "agent_hash",
+    "guid",
+    "memory",
+    "network",
+    "software",
+    "storage",
+    "cpu",
+    "device_type",
+    "domain",
+    "external_ip",
+    "internal_ip",
+    "last_reboot",
+    "last_seen",
+    "last_user",
+    "operating_system",
+    "uptime",
+    "agent_id",
+]
+
+
+def _device_column_sql(alias: Optional[str] = None) -> str:
+    if alias:
+        return ", ".join(f"{alias}.{col}" for col in _DEVICE_TABLE_COLUMNS)
+    return ", ".join(_DEVICE_TABLE_COLUMNS)
+
+
+def _parse_device_json(raw: Optional[str], default: Any) -> Any:
+    candidate = default
+    if raw is None:
+        return json.loads(json.dumps(default)) if isinstance(default, (list, dict)) else default
+    try:
+        data = json.loads(raw)
+    except Exception:
+        data = None
+    if isinstance(default, list):
+        if isinstance(data, list):
+            return data
+        return []
+    if isinstance(default, dict):
+        if isinstance(data, dict):
+            return data
+        return {}
+    return default
+
+
+def _ts_to_iso(ts: Optional[int]) -> str:
+    if not ts:
+        return ""
+    try:
+        from datetime import datetime, timezone
+
+        return datetime.fromtimestamp(int(ts), timezone.utc).isoformat()
+    except Exception:
+        return ""
+
+
+def _ts_to_human(ts: Optional[int]) -> str:
+    if not ts:
+        return ""
+    try:
+        from datetime import datetime
+
+        return datetime.utcfromtimestamp(int(ts)).strftime("%Y-%m-%d %H:%M:%S")
+    except Exception:
+        return ""
+
+
+def _row_to_device_dict(row: Sequence[Any], columns: Sequence[str]) -> Dict[str, Any]:
+    return {columns[idx]: row[idx] for idx in range(min(len(row), len(columns)))}
+
+
+def _assemble_device_snapshot(record: Dict[str, Any]) -> Dict[str, Any]:
+    parsed_lists: Dict[str, List[Any]] = {}
+    for field, default in _DEVICE_JSON_LIST_FIELDS.items():
+        parsed_lists[field] = _parse_device_json(record.get(field), default)
+    cpu_obj = _parse_device_json(record.get("cpu"), _DEVICE_JSON_OBJECT_FIELDS["cpu"])
+
+    created_ts = _coerce_int(record.get("created_at")) or 0
+    last_seen_ts = _coerce_int(record.get("last_seen")) or 0
+    uptime_val = _coerce_int(record.get("uptime")) or 0
+
+    agent_hash = _clean_device_str(record.get("agent_hash")) or ""
+    normalized_guid = _normalize_guid(record.get("guid")) if record.get("guid") else ""
+
+    summary: Dict[str, Any] = {
+        "hostname": record.get("hostname") or "",
+        "description": record.get("description") or "",
+        "agent_hash": agent_hash,
+        "agent_guid": normalized_guid,
+        "agent_id": _clean_device_str(record.get("agent_id")) or "",
+        "device_type": _clean_device_str(record.get("device_type")) or "",
+        "domain": _clean_device_str(record.get("domain")) or "",
+        "external_ip": _clean_device_str(record.get("external_ip")) or "",
+        "internal_ip": _clean_device_str(record.get("internal_ip")) or "",
+        "last_reboot": _clean_device_str(record.get("last_reboot")) or "",
+        "last_seen": last_seen_ts,
+        "last_user": _clean_device_str(record.get("last_user")) or "",
+        "operating_system": _clean_device_str(record.get("operating_system")) or "",
+        "uptime": uptime_val,
+        "uptime_sec": uptime_val,
+        "created_at": created_ts,
+        "created": _ts_to_human(created_ts),
+    }
+
+    details = {
+        "summary": summary,
+        "memory": parsed_lists["memory"],
+        "network": parsed_lists["network"],
+        "software": parsed_lists["software"],
+        "storage": parsed_lists["storage"],
+        "cpu": cpu_obj,
+    }
+
+    payload: Dict[str, Any] = {
+        "hostname": summary["hostname"],
+        "description": summary.get("description", ""),
+        "created_at": created_ts,
+        "created_at_iso": _ts_to_iso(created_ts),
+        "agent_hash": agent_hash,
+        "agent_guid": normalized_guid,
+        "guid": normalized_guid,
+        "memory": parsed_lists["memory"],
+        "network": parsed_lists["network"],
+        "software": parsed_lists["software"],
+        "storage": parsed_lists["storage"],
+        "cpu": cpu_obj,
+        "device_type": summary.get("device_type", ""),
+        "domain": summary.get("domain", ""),
+        "external_ip": summary.get("external_ip", ""),
+        "internal_ip": summary.get("internal_ip", ""),
+        "last_reboot": summary.get("last_reboot", ""),
+        "last_seen": last_seen_ts,
+        "last_seen_iso": _ts_to_iso(last_seen_ts),
+        "last_user": summary.get("last_user", ""),
+        "operating_system": summary.get("operating_system", ""),
+        "uptime": uptime_val,
+        "agent_id": summary.get("agent_id", ""),
+        "details": details,
+        "summary": summary,
+    }
+    return payload
+
+
+def _load_device_snapshot(
+    cur: sqlite3.Cursor,
+    *,
+    hostname: Optional[str] = None,
+    guid: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    if hostname:
+        cur.execute(
+            f"SELECT {_device_column_sql()} FROM {DEVICE_TABLE} WHERE hostname = ?",
+            (hostname,),
+        )
+    elif guid:
+        normalized_guid = _normalize_guid(guid)
+        if not normalized_guid:
+            return None
+        cur.execute(
+            f"SELECT {_device_column_sql()} FROM {DEVICE_TABLE} WHERE LOWER(guid) = ?",
+            (normalized_guid.lower(),),
+        )
+    else:
+        return None
+    row = cur.fetchone()
+    if not row:
+        return None
+    record = _row_to_device_dict(row, _DEVICE_TABLE_COLUMNS)
+    return _assemble_device_snapshot(record)
+
+
 def _serialize_device_json(value: Any, default: Any) -> str:
     candidate = value
     if candidate is None:
@@ -2550,10 +2714,6 @@ def _device_upsert(
 ) -> None:
     if not hostname:
         return
-    try:
-        details_json = json.dumps(merged_details or {})
-    except Exception:
-        details_json = json.dumps({})
     column_values = _extract_device_columns(merged_details or {})
 
     normalized_description = description if description is not None else ""
@@ -2578,7 +2738,6 @@ def _device_upsert(
         INSERT INTO {DEVICE_TABLE}(
             hostname,
             description,
-            details,
             created_at,
             agent_hash,
             guid,
@@ -2597,10 +2756,9 @@ def _device_upsert(
             operating_system,
             uptime,
             agent_id
-        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
         ON CONFLICT(hostname) DO UPDATE SET
             description=excluded.description,
-            details=excluded.details,
             created_at=COALESCE({DEVICE_TABLE}.created_at, excluded.created_at),
             agent_hash=COALESCE(NULLIF(excluded.agent_hash, ''), {DEVICE_TABLE}.agent_hash),
             guid=COALESCE(NULLIF(excluded.guid, ''), {DEVICE_TABLE}.guid),
@@ -2624,7 +2782,6 @@ def _device_upsert(
     params: List[Any] = [
         hostname,
         normalized_description,
-        details_json,
         created_ts,
         normalized_hash,
         normalized_guid,
@@ -2753,7 +2910,6 @@ def init_db():
                 CREATE TABLE IF NOT EXISTS devices (
                     hostname TEXT PRIMARY KEY,
                     description TEXT,
-                    details TEXT,
                     created_at INTEGER,
                     agent_hash TEXT,
                     guid TEXT,
@@ -2786,7 +2942,6 @@ def init_db():
             existing_cols.append(name)
 
     _ensure_column("description", "TEXT")
-    _ensure_column("details", "TEXT")
     _ensure_column("created_at", "INTEGER")
     _ensure_column("agent_hash", "TEXT")
     _ensure_column("guid", "TEXT")
@@ -2806,31 +2961,94 @@ def init_db():
     _ensure_column("uptime", "INTEGER")
     _ensure_column("agent_id", "TEXT")
 
-    # Backfill expanded columns from stored JSON
-    try:
-        cur.execute(f"SELECT hostname, details FROM {DEVICE_TABLE}")
-        rows = cur.fetchall()
-        for hostname, details_json in rows:
+    details_rows: List[Tuple[Any, ...]] = []
+    if "details" in existing_cols:
+        try:
+            cur.execute(f"SELECT hostname, details FROM {DEVICE_TABLE}")
+            details_rows = cur.fetchall()
+        except Exception:
+            details_rows = []
+        for hostname, details_json in details_rows:
             try:
                 details = json.loads(details_json or "{}")
             except Exception:
                 details = {}
             column_values = _extract_device_columns(details)
-            update_fields = []
-            params: List[Any] = []
-            for key, value in column_values.items():
-                if key not in existing_cols:
-                    continue
-                update_fields.append(f"{key}=?")
-                params.append(value)
-            if update_fields:
-                params.append(hostname)
+            params = [column_values.get(col) for col in (
+                "memory",
+                "network",
+                "software",
+                "storage",
+                "cpu",
+                "device_type",
+                "domain",
+                "external_ip",
+                "internal_ip",
+                "last_reboot",
+                "last_seen",
+                "last_user",
+                "operating_system",
+                "uptime",
+                "agent_id",
+            )]
+            cur.execute(
+                f"""
+                UPDATE {DEVICE_TABLE}
+                SET memory=?, network=?, software=?, storage=?, cpu=?,
+                    device_type=?, domain=?, external_ip=?, internal_ip=?,
+                    last_reboot=?, last_seen=?, last_user=?, operating_system=?,
+                    uptime=?, agent_id=?
+                WHERE hostname=?
+                """,
+                params + [hostname],
+            )
+
+        if "details" in existing_cols:
+            try:
+                cur.execute(f"ALTER TABLE {DEVICE_TABLE} DROP COLUMN details")
+                existing_cols.remove("details")
+            except sqlite3.OperationalError:
+                try:
+                    cur.execute("BEGIN")
+                except Exception:
+                    pass
+                temp_table = f"{DEVICE_TABLE}_old"
+                cur.execute(f"ALTER TABLE {DEVICE_TABLE} RENAME TO {temp_table}")
                 cur.execute(
-                    f"UPDATE {DEVICE_TABLE} SET {', '.join(update_fields)} WHERE hostname=?",
-                    params,
+                    """
+                    CREATE TABLE IF NOT EXISTS devices (
+                        hostname TEXT PRIMARY KEY,
+                        description TEXT,
+                        created_at INTEGER,
+                        agent_hash TEXT,
+                        guid TEXT,
+                        memory TEXT,
+                        network TEXT,
+                        software TEXT,
+                        storage TEXT,
+                        cpu TEXT,
+                        device_type TEXT,
+                        domain TEXT,
+                        external_ip TEXT,
+                        internal_ip TEXT,
+                        last_reboot TEXT,
+                        last_seen INTEGER,
+                        last_user TEXT,
+                        operating_system TEXT,
+                        uptime INTEGER,
+                        agent_id TEXT
+                    )
+                    """
                 )
-    except Exception:
-        pass
+                copy_cols = [col for col in _DEVICE_TABLE_COLUMNS if col != "details"]
+                col_sql = ", ".join(copy_cols)
+                cur.execute(
+                    f"INSERT INTO {DEVICE_TABLE} ({col_sql}) SELECT {col_sql} FROM {temp_table}"
+                )
+                cur.execute(f"DROP TABLE {temp_table}")
+                cur.execute("COMMIT")
+                cur.execute(f"PRAGMA table_info({DEVICE_TABLE})")
+                existing_cols = [r[1] for r in cur.fetchall()]
 
     # Activity history table for script/job runs
     cur.execute(
@@ -3281,15 +3499,13 @@ def rename_site():
 def _load_device_records(limit: int = 0):
     """
     Load device records from SQLite and flatten commonly-searched fields
-    from the JSON details column. Returns a list of dicts with keys:
+    from the devices table. Returns a list of dicts with keys:
       hostname, description, last_user, internal_ip, external_ip, site_id, site_name
     """
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        cur.execute(
-            f"SELECT hostname, description, last_user, internal_ip, external_ip, details FROM {DEVICE_TABLE}"
-        )
+        cur.execute(f"SELECT {_device_column_sql()} FROM {DEVICE_TABLE}")
         rows = cur.fetchall()
 
         # Build device -> site mapping
@@ -3308,18 +3524,16 @@ def _load_device_records(limit: int = 0):
         site_map = {}
 
     out = []
-    for hostname, description, last_user, internal_ip, external_ip, details_json in rows:
-        summary = {}
-        try:
-            summary = (json.loads(details_json or "{}") or {}).get("summary") or {}
-        except Exception:
-            summary = {}
+    for row in rows:
+        record = _row_to_device_dict(row, _DEVICE_TABLE_COLUMNS)
+        snapshot = _assemble_device_snapshot(record)
+        summary = snapshot.get("summary", {})
         rec = {
-            "hostname": hostname or summary.get("hostname") or "",
-            "description": (description or summary.get("description") or ""),
-            "last_user": last_user or summary.get("last_user") or summary.get("last_user_name") or "",
-            "internal_ip": internal_ip or summary.get("internal_ip") or "",
-            "external_ip": external_ip or summary.get("external_ip") or "",
+            "hostname": snapshot.get("hostname") or summary.get("hostname") or "",
+            "description": snapshot.get("description") or summary.get("description") or "",
+            "last_user": snapshot.get("last_user") or summary.get("last_user") or summary.get("last_user_name") or "",
+            "internal_ip": snapshot.get("internal_ip") or summary.get("internal_ip") or "",
+            "external_ip": snapshot.get("external_ip") or summary.get("external_ip") or "",
         }
         site_info = site_map.get(rec["hostname"]) or {}
         rec.update({
@@ -3430,11 +3644,7 @@ def list_devices():
         cur = conn.cursor()
         cur.execute(
             f"""
-            SELECT d.hostname, d.description, d.details, d.created_at, d.agent_hash, d.guid,
-                   d.memory, d.network, d.software, d.storage, d.cpu,
-                   d.device_type, d.domain, d.external_ip, d.internal_ip,
-                   d.last_reboot, d.last_seen, d.last_user, d.operating_system,
-                   d.uptime, d.agent_id,
+            SELECT {_device_column_sql('d')},
                    s.id, s.name, s.description
             FROM {DEVICE_TABLE} d
             LEFT JOIN device_sites ds ON ds.device_hostname = d.hostname
@@ -3446,69 +3656,15 @@ def list_devices():
     except Exception as exc:
         return jsonify({"error": str(exc)}), 500
 
-    def _parse_json_list(raw: Optional[str]) -> list:
-        try:
-            return json.loads(raw or "[]")
-        except Exception:
-            return []
-
-    def _parse_json_obj(raw: Optional[str]) -> dict:
-        try:
-            return json.loads(raw or "{}")
-        except Exception:
-            return {}
-
-    def _ts_to_iso(ts: Optional[int]) -> str:
-        if not ts:
-            return ""
-        try:
-            from datetime import datetime, timezone
-
-            return datetime.fromtimestamp(int(ts), timezone.utc).isoformat()
-        except Exception:
-            return ""
-
     devices = []
     now = time.time()
     for row in rows:
-        (
-            hostname,
-            description,
-            details_json,
-            created_at,
-            agent_hash,
-            guid,
-            memory_json,
-            network_json,
-            software_json,
-            storage_json,
-            cpu_json,
-            device_type,
-            domain,
-            external_ip,
-            internal_ip,
-            last_reboot,
-            last_seen,
-            last_user,
-            operating_system,
-            uptime,
-            agent_id,
-            site_id,
-            site_name,
-            site_description,
-        ) = row
-        try:
-            details = json.loads(details_json or "{}")
-        except Exception:
-            details = {}
-        summary = details.get("summary") or {}
-        if description:
-            summary.setdefault("description", description)
-        if agent_hash:
-            summary.setdefault("agent_hash", agent_hash)
-        normalized_guid = _normalize_guid(guid) if guid else ""
-        if normalized_guid:
-            summary.setdefault("agent_guid", normalized_guid)
+        core = row[: len(_DEVICE_TABLE_COLUMNS)]
+        site_id, site_name, site_description = row[len(_DEVICE_TABLE_COLUMNS) :]
+        record = _row_to_device_dict(core, _DEVICE_TABLE_COLUMNS)
+        snapshot = _assemble_device_snapshot(record)
+        summary = snapshot.get("summary", {})
+        last_seen = snapshot.get("last_seen") or 0
         status = "Offline"
         try:
             if last_seen and (now - float(last_seen)) <= 300:
@@ -3517,33 +3673,34 @@ def list_devices():
             pass
         devices.append(
             {
-                "hostname": hostname or summary.get("hostname") or "",
-                "description": description or summary.get("description") or "",
-                "details": details,
+                "hostname": snapshot.get("hostname") or summary.get("hostname") or "",
+                "description": snapshot.get("description") or summary.get("description") or "",
+                "details": snapshot.get("details", {}),
                 "summary": summary,
-                "created_at": int(created_at or 0),
-                "created_at_iso": _ts_to_iso(created_at),
-                "agent_hash": (agent_hash or "").strip() if agent_hash else summary.get("agent_hash", ""),
-                "agent_guid": normalized_guid,
-                "memory": _parse_json_list(memory_json),
-                "network": _parse_json_list(network_json),
-                "software": _parse_json_list(software_json),
-                "storage": _parse_json_list(storage_json),
-                "cpu": _parse_json_obj(cpu_json),
-                "device_type": (device_type or "").strip() or summary.get("device_type") or "",
-                "domain": (domain or "").strip(),
-                "external_ip": (external_ip or "").strip() or summary.get("external_ip") or "",
-                "internal_ip": (internal_ip or "").strip() or summary.get("internal_ip") or "",
-                "last_reboot": (last_reboot or "").strip() or summary.get("last_reboot") or "",
-                "last_seen": int(last_seen or 0),
-                "last_seen_iso": _ts_to_iso(last_seen),
-                "last_user": (last_user or "").strip() or summary.get("last_user") or "",
-                "operating_system": (operating_system or "").strip()
+                "created_at": snapshot.get("created_at") or 0,
+                "created_at_iso": snapshot.get("created_at_iso") or _ts_to_iso(snapshot.get("created_at")),
+                "agent_hash": snapshot.get("agent_hash") or summary.get("agent_hash") or "",
+                "agent_guid": snapshot.get("agent_guid") or summary.get("agent_guid") or "",
+                "guid": snapshot.get("agent_guid") or summary.get("agent_guid") or "",
+                "memory": snapshot.get("memory", []),
+                "network": snapshot.get("network", []),
+                "software": snapshot.get("software", []),
+                "storage": snapshot.get("storage", []),
+                "cpu": snapshot.get("cpu", {}),
+                "device_type": snapshot.get("device_type") or summary.get("device_type") or "",
+                "domain": snapshot.get("domain") or "",
+                "external_ip": snapshot.get("external_ip") or summary.get("external_ip") or "",
+                "internal_ip": snapshot.get("internal_ip") or summary.get("internal_ip") or "",
+                "last_reboot": snapshot.get("last_reboot") or summary.get("last_reboot") or "",
+                "last_seen": last_seen,
+                "last_seen_iso": snapshot.get("last_seen_iso") or _ts_to_iso(last_seen),
+                "last_user": snapshot.get("last_user") or summary.get("last_user") or "",
+                "operating_system": snapshot.get("operating_system")
                 or summary.get("operating_system")
                 or summary.get("agent_operating_system")
                 or "",
-                "uptime": int(uptime or 0),
-                "agent_id": (agent_id or "").strip() or summary.get("agent_id") or "",
+                "uptime": snapshot.get("uptime") or 0,
+                "agent_id": snapshot.get("agent_id") or summary.get("agent_id") or "",
                 "site_id": site_id,
                 "site_name": site_name or "",
                 "site_description": site_description or "",
@@ -3554,6 +3711,54 @@ def list_devices():
     return jsonify({"devices": devices})
 
 
+@app.route("/api/devices/<guid>", methods=["GET"])
+def get_device_by_guid(guid: str):
+    try:
+        conn = _db_conn()
+        cur = conn.cursor()
+        snapshot = _load_device_snapshot(cur, guid=guid)
+        site_info = {"site_id": None, "site_name": "", "site_description": ""}
+        if snapshot:
+            try:
+                cur.execute(
+                    """
+                    SELECT s.id, s.name, s.description
+                    FROM device_sites ds
+                    JOIN sites s ON s.id = ds.site_id
+                    WHERE ds.device_hostname = ?
+                    """,
+                    (snapshot.get("hostname"),),
+                )
+                site_row = cur.fetchone()
+                if site_row:
+                    site_info = {
+                        "site_id": site_row[0],
+                        "site_name": site_row[1] or "",
+                        "site_description": site_row[2] or "",
+                    }
+            except Exception:
+                pass
+        conn.close()
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500
+
+    if not snapshot:
+        return jsonify({"error": "not found"}), 404
+
+    last_seen = snapshot.get("last_seen") or 0
+    status = "Offline"
+    try:
+        if last_seen and (time.time() - float(last_seen)) <= 300:
+            status = "Online"
+    except Exception:
+        pass
+
+    payload = dict(snapshot)
+    payload.update(site_info)
+    payload["status"] = status
+    return jsonify(payload)
+
+
 # ---------------------------------------------
 # Device List Views API
 # ---------------------------------------------
@@ -3722,23 +3927,11 @@ def _persist_last_seen(hostname: str, last_seen: int, agent_id: str = None):
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        cur.execute(
-            f"SELECT details, description, created_at, guid, agent_hash FROM {DEVICE_TABLE} WHERE hostname = ?",
-            (hostname,),
-        )
-        row = cur.fetchone()
-        if row and row[0]:
-            try:
-                details = json.loads(row[0])
-            except Exception:
-                details = {}
-            description = row[1] or ""
-            created_at = int(row[2] or 0)
-        else:
-            details = {}
-            description = ""
-            created_at = 0
-        existing_hash = row[4] if row and len(row) > 4 else None
+        snapshot = _load_device_snapshot(cur, hostname=hostname) or {}
+        details = snapshot.get("details", {})
+        description = snapshot.get("description") or ""
+        created_at = int(snapshot.get("created_at") or 0)
+        existing_hash = snapshot.get("agent_hash")
 
         summary = details.get("summary") or {}
         summary["hostname"] = summary.get("hostname") or hostname
@@ -3752,7 +3945,7 @@ def _persist_last_seen(hostname: str, last_seen: int, agent_id: str = None):
             except Exception:
                 pass
         try:
-            existing_guid = (row[3] or "").strip() if row and len(row) > 3 else ""
+            existing_guid = (snapshot.get("agent_guid") or "").strip()
         except Exception:
             existing_guid = ""
         if existing_guid and not summary.get("agent_guid"):
@@ -3792,25 +3985,20 @@ def load_agents_from_db():
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        cur.execute(
-            f"SELECT hostname, description, details, created_at, agent_hash, guid FROM {DEVICE_TABLE}"
-        )
+        cur.execute(f"SELECT {_device_column_sql()} FROM {DEVICE_TABLE}")
         rows = cur.fetchall()
-        for hostname, description, details_json, created_at, agent_hash, guid in rows:
-            try:
-                details = json.loads(details_json or "{}")
-            except Exception:
-                details = {}
+        for row in rows:
+            record = _row_to_device_dict(row, _DEVICE_TABLE_COLUMNS)
+            snapshot = _assemble_device_snapshot(record)
+            hostname = snapshot.get("hostname")
+            description = snapshot.get("description")
+            details = snapshot.get("details", {})
             summary = details.get("summary", {})
             agent_id = summary.get("agent_id") or hostname
-            stored_hash = None
-            try:
-                stored_hash = (agent_hash or summary.get("agent_hash") or "").strip()
-            except Exception:
-                stored_hash = summary.get("agent_hash") or ""
-            agent_guid = (summary.get("agent_guid") or guid or "").strip()
-            if guid and not summary.get("agent_guid"):
-                normalized_guid = _normalize_guid(guid)
+            stored_hash = (snapshot.get("agent_hash") or summary.get("agent_hash") or "").strip()
+            agent_guid = (summary.get("agent_guid") or snapshot.get("agent_guid") or "").strip()
+            if snapshot.get("agent_guid") and not summary.get("agent_guid"):
+                normalized_guid = _normalize_guid(snapshot.get("agent_guid"))
                 summary["agent_guid"] = normalized_guid
                 try:
                     _device_upsert(
@@ -3818,8 +4006,8 @@ def load_agents_from_db():
                         hostname,
                         description,
                         details,
-                        created_at,
-                        agent_hash=agent_hash or stored_hash,
+                        snapshot.get("created_at"),
+                        agent_hash=snapshot.get("agent_hash") or stored_hash,
                         guid=normalized_guid,
                     )
                 except Exception:
@@ -3871,28 +4059,26 @@ def _device_rows_for_agent(cur, agent_id: str) -> List[Dict[str, Any]]:
         return results
     try:
         cur.execute(
-            f"SELECT hostname, agent_hash, details, guid FROM {DEVICE_TABLE} WHERE LOWER(hostname) = ?",
+            f"SELECT {_device_column_sql()} FROM {DEVICE_TABLE} WHERE LOWER(hostname) = ?",
             (base_host.lower(),),
         )
         rows = cur.fetchall()
     except Exception:
         return results
-    for hostname, agent_hash, details_json, guid in rows or []:
-        try:
-            details = json.loads(details_json or "{}")
-        except Exception:
-            details = {}
-        summary = details.get("summary") or {}
+    for row in rows or []:
+        record = _row_to_device_dict(row, _DEVICE_TABLE_COLUMNS)
+        snapshot = _assemble_device_snapshot(record)
+        summary = snapshot.get("summary", {})
         summary_agent = (summary.get("agent_id") or "").strip()
         matched = summary_agent.lower() == normalized_id.lower() if summary_agent else False
         results.append(
             {
-                "hostname": hostname,
-                "agent_hash": (agent_hash or "").strip(),
-                "details": details,
+                "hostname": snapshot.get("hostname"),
+                "agent_hash": (snapshot.get("agent_hash") or "").strip(),
+                "details": snapshot.get("details", {}),
                 "summary_agent_id": summary_agent,
                 "matched": matched,
-                "guid": (guid or "").strip(),
+                "guid": snapshot.get("agent_guid") or "",
             }
         )
     return results
@@ -3912,27 +4098,21 @@ def _ensure_agent_guid_for_hostname(cur, hostname: str, agent_id: Optional[str]
     normalized_host = (hostname or "").strip()
     if not normalized_host:
         return None
-    cur.execute(
-        f"SELECT hostname, guid, details, description, created_at, agent_hash FROM {DEVICE_TABLE} WHERE LOWER(hostname) = ?",
-        (normalized_host.lower(),),
-    )
-    row = cur.fetchone()
-    if row:
-        actual_host = row[0]
-        existing_guid = row[1] or ""
-        details_json = row[2] or "{}"
-        description = row[3] if len(row) > 3 else ""
-        created_at = row[4] if len(row) > 4 else None
-        agent_hash = row[5] if len(row) > 5 else None
+    snapshot = _load_device_snapshot(cur, hostname=normalized_host)
+    if snapshot:
+        actual_host = snapshot.get("hostname") or normalized_host
+        existing_guid = snapshot.get("agent_guid") or ""
+        details = snapshot.get("details", {})
+        description = snapshot.get("description") or ""
+        created_at = snapshot.get("created_at")
+        agent_hash = snapshot.get("agent_hash")
     else:
-        actual_host, existing_guid, details_json = normalized_host, "", "{}"
+        actual_host = normalized_host
+        existing_guid = ""
+        details = {}
         description = ""
         created_at = None
         agent_hash = None
-    try:
-        details = json.loads(details_json or "{}")
-    except Exception:
-        details = {}
     summary = details.setdefault("summary", {})
     if agent_id and not summary.get("agent_id"):
         try:
@@ -3985,14 +4165,10 @@ def _ensure_agent_guid(agent_id: str, hostname: Optional[str] = None) -> Optiona
                 summary = row.get("details", {}).setdefault("summary", {})
                 summary.setdefault("agent_guid", candidate)
                 host = row.get("hostname")
-                cur.execute(
-                    f"SELECT description, created_at, agent_hash FROM {DEVICE_TABLE} WHERE hostname = ?",
-                    (host,),
-                )
-                info = cur.fetchone()
-                description = info[0] if info else None
-                created_at = info[1] if info else None
-                agent_hash = info[2] if info else None
+                snapshot_existing = _load_device_snapshot(cur, hostname=host)
+                description = snapshot_existing.get("description") if snapshot_existing else None
+                created_at = snapshot_existing.get("created_at") if snapshot_existing else None
+                agent_hash = snapshot_existing.get("agent_hash") if snapshot_existing else None
                 _device_upsert(
                     cur,
                     host,
@@ -4106,37 +4282,15 @@ def save_agent_details():
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        # Load existing row to preserve description and created_at and merge fields
-        cur.execute(
-            f"SELECT details, description, created_at, guid, agent_hash FROM {DEVICE_TABLE} WHERE hostname = ?",
-            (hostname,),
-        )
-        row = cur.fetchone()
-        prev_details = {}
-        description = ""
-        created_at = 0
-        existing_guid = None
-        existing_agent_hash = None
-        if row:
-            try:
-                prev_details = json.loads(row[0] or '{}')
-            except Exception:
-                prev_details = {}
-            description = row[1] or ""
-            try:
-                created_at = int(row[2] or 0)
-            except Exception:
-                created_at = 0
-            try:
-                existing_guid = (row[3] or "").strip()
-            except Exception:
-                existing_guid = None
-            try:
-                existing_agent_hash = (row[4] or "").strip()
-            except Exception:
-                existing_agent_hash = None
-        else:
-            existing_guid = None
+        snapshot = _load_device_snapshot(cur, hostname=hostname) or {}
+        try:
+            prev_details = json.loads(json.dumps(snapshot.get("details", {})))
+        except Exception:
+            prev_details = snapshot.get("details", {}) or {}
+        description = snapshot.get("description") or ""
+        created_at = int(snapshot.get("created_at") or 0)
+        existing_guid = (snapshot.get("agent_guid") or "").strip() or None
+        existing_agent_hash = (snapshot.get("agent_hash") or "").strip() or None
 
         # Ensure summary exists and attach hostname/agent_id if missing
         incoming_summary = details.setdefault("summary", {})
@@ -4250,84 +4404,35 @@ def get_device_details(hostname: str):
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        cur.execute(
-            f"""
-            SELECT details, description, created_at, agent_hash, guid,
-                   memory, network, software, storage, cpu,
-                   device_type, domain, external_ip, internal_ip,
-                   last_reboot, last_seen, last_user, operating_system,
-                   uptime, agent_id
-            FROM {DEVICE_TABLE}
-            WHERE hostname = ?
-            """,
-            (hostname,),
-        )
-        row = cur.fetchone()
+        snapshot = _load_device_snapshot(cur, hostname=hostname)
         conn.close()
-        if row:
-            try:
-                details = json.loads(row[0])
-            except Exception:
-                details = {}
-            description = row[1] if len(row) > 1 else ""
-            created_at = int(row[2] or 0) if len(row) > 2 else 0
-            agent_hash = (row[3] or "").strip() if len(row) > 3 else ""
-            if description:
-                details.setdefault("summary", {})["description"] = description
-            # Ensure created string exists from created_at
-            try:
-                if created_at and not (details.get('summary') or {}).get('created'):
-                    from datetime import datetime
-                    details.setdefault('summary', {})['created'] = datetime.utcfromtimestamp(created_at).strftime('%Y-%m-%d %H:%M:%S')
-            except Exception:
-                pass
-            if agent_hash:
-                try:
-                    details.setdefault('summary', {})
-                    if not details['summary'].get('agent_hash'):
-                        details['summary']['agent_hash'] = agent_hash
-                except Exception:
-                    pass
-            agent_guid = (row[4] or "").strip() if len(row) > 4 else ""
-            normalized_guid = _normalize_guid(agent_guid) if agent_guid else ""
-            if normalized_guid:
-                details.setdefault('summary', {})
-                details['summary'].setdefault('agent_guid', normalized_guid)
-
-            def _parse_list(raw: Optional[str]) -> list:
-                try:
-                    return json.loads(raw or '[]')
-                except Exception:
-                    return []
-
-            def _parse_obj(raw: Optional[str]) -> dict:
-                try:
-                    return json.loads(raw or '{}')
-                except Exception:
-                    return {}
-
+        if snapshot:
+            summary = snapshot.get("summary", {})
             payload = {
-                "details": details,
-                "summary": details.get("summary", {}),
-                "description": description or "",
-                "created_at": created_at,
-                "agent_hash": agent_hash,
-                "agent_guid": normalized_guid,
-                "memory": _parse_list(row[5] if len(row) > 5 else None),
-                "network": _parse_list(row[6] if len(row) > 6 else None),
-                "software": _parse_list(row[7] if len(row) > 7 else None),
-                "storage": _parse_list(row[8] if len(row) > 8 else None),
-                "cpu": _parse_obj(row[9] if len(row) > 9 else None),
-                "device_type": (row[10] or "").strip() if len(row) > 10 and row[10] else "",
-                "domain": (row[11] or "").strip() if len(row) > 11 and row[11] else "",
-                "external_ip": (row[12] or "").strip() if len(row) > 12 and row[12] else "",
-                "internal_ip": (row[13] or "").strip() if len(row) > 13 and row[13] else "",
-                "last_reboot": (row[14] or "").strip() if len(row) > 14 and row[14] else "",
-                "last_seen": int(row[15] or 0) if len(row) > 15 and row[15] is not None else 0,
-                "last_user": (row[16] or "").strip() if len(row) > 16 and row[16] else "",
-                "operating_system": (row[17] or "").strip() if len(row) > 17 and row[17] else "",
-                "uptime": int(row[18] or 0) if len(row) > 18 and row[18] is not None else 0,
-                "agent_id": (row[19] or "").strip() if len(row) > 19 and row[19] else "",
+                "details": snapshot.get("details", {}),
+                "summary": summary,
+                "description": snapshot.get("description") or summary.get("description") or "",
+                "created_at": snapshot.get("created_at") or 0,
+                "agent_hash": snapshot.get("agent_hash") or summary.get("agent_hash") or "",
+                "agent_guid": snapshot.get("agent_guid") or summary.get("agent_guid") or "",
+                "memory": snapshot.get("memory", []),
+                "network": snapshot.get("network", []),
+                "software": snapshot.get("software", []),
+                "storage": snapshot.get("storage", []),
+                "cpu": snapshot.get("cpu", {}),
+                "device_type": snapshot.get("device_type") or summary.get("device_type") or "",
+                "domain": snapshot.get("domain") or summary.get("domain") or "",
+                "external_ip": snapshot.get("external_ip") or summary.get("external_ip") or "",
+                "internal_ip": snapshot.get("internal_ip") or summary.get("internal_ip") or "",
+                "last_reboot": snapshot.get("last_reboot") or summary.get("last_reboot") or "",
+                "last_seen": snapshot.get("last_seen") or summary.get("last_seen") or 0,
+                "last_user": snapshot.get("last_user") or summary.get("last_user") or "",
+                "operating_system": snapshot.get("operating_system")
+                or summary.get("operating_system")
+                or summary.get("agent_operating_system")
+                or "",
+                "uptime": snapshot.get("uptime") or summary.get("uptime") or 0,
+                "agent_id": snapshot.get("agent_id") or summary.get("agent_id") or "",
             }
             return jsonify(payload)
     except Exception:
@@ -4342,24 +4447,15 @@ def set_device_description(hostname: str):
     try:
         conn = _db_conn()
         cur = conn.cursor()
-        cur.execute(
-            f"SELECT details, created_at, agent_hash, guid, description FROM {DEVICE_TABLE} WHERE hostname = ?",
-            (hostname,),
-        )
-        row = cur.fetchone()
-        if row:
-            details_json, created_at, agent_hash, guid, existing_description = row
-            try:
-                details = json.loads(details_json or "{}")
-            except Exception:
-                details = {}
-            created_at = created_at or int(time.time())
-        else:
-            details = {}
-            created_at = int(time.time())
-            agent_hash = None
-            guid = None
-            existing_description = ""
+        snapshot = _load_device_snapshot(cur, hostname=hostname) or {}
+        try:
+            details = json.loads(json.dumps(snapshot.get("details", {})))
+        except Exception:
+            details = snapshot.get("details", {}) or {}
+        created_at = snapshot.get("created_at") or int(time.time())
+        agent_hash = snapshot.get("agent_hash")
+        guid = snapshot.get("agent_guid")
+        existing_description = snapshot.get("description") or ""
         summary = details.setdefault("summary", {})
         summary["description"] = description
         _device_upsert(
@@ -5393,26 +5489,15 @@ def handle_collector_status(data):
             host = hostname or rec.get('hostname')
             conn = _db_conn()
             cur = conn.cursor()
-            cur.execute(
-                f"SELECT details, description, created_at, agent_hash, guid FROM {DEVICE_TABLE} WHERE hostname = ?",
-                (host,),
-            )
-            row = cur.fetchone()
-            if row and row[0]:
-                try:
-                    details = json.loads(row[0])
-                except Exception:
-                    details = {}
-                description = row[1] or ""
-                created_at = int(row[2] or 0)
-                existing_hash = (row[3] or "").strip() if len(row) > 3 else None
-                existing_guid = (row[4] or "").strip() if len(row) > 4 else None
-            else:
-                details = {}
-                description = ""
-                created_at = 0
-                existing_hash = None
-                existing_guid = None
+            snapshot = _load_device_snapshot(cur, hostname=host) or {}
+            try:
+                details = json.loads(json.dumps(snapshot.get("details", {})))
+            except Exception:
+                details = snapshot.get("details", {}) or {}
+            description = snapshot.get("description") or ""
+            created_at = int(snapshot.get("created_at") or 0)
+            existing_hash = (snapshot.get("agent_hash") or "").strip() or None
+            existing_guid = (snapshot.get("agent_guid") or "").strip() or None
             summary = details.get('summary') or {}
             # Only update last_user if provided; do not clear other fields
             summary['last_user'] = last_user

From e268bc2f5a4fa6213c538fa2dbcc760a1920b221 Mon Sep 17 00:00:00 2001
From: Nicole Rappe <nicole.rappe@bunny-lab.io>
Date: Wed, 8 Oct 2025 21:41:10 -0600
Subject: [PATCH 3/4] Restore repo hash endpoint and align device list

---
 Data/Server/WebUI/src/Devices/Device_List.jsx | 25 +++++++++---
 Data/Server/server.py                         | 38 +++++++++++++++++++
 2 files changed, 58 insertions(+), 5 deletions(-)

diff --git a/Data/Server/WebUI/src/Devices/Device_List.jsx b/Data/Server/WebUI/src/Devices/Device_List.jsx
index 52531ef1..1be8e90c 100644
--- a/Data/Server/WebUI/src/Devices/Device_List.jsx
+++ b/Data/Server/WebUI/src/Devices/Device_List.jsx
@@ -146,11 +146,21 @@ export default function DeviceList({ onSelectDevice }) {
   const [assignTargets, setAssignTargets] = useState([]); // hostnames
 
   const [repoHash, setRepoHash] = useState(null);
+  const lastRepoFetchRef = useRef(0);
 
-  const fetchLatestRepoHash = useCallback(async () => {
+  const fetchLatestRepoHash = useCallback(async (options = {}) => {
+    const { force = false } = options || {};
+    const now = Date.now();
+    const elapsed = now - lastRepoFetchRef.current;
+    if (!force && repoHash && elapsed >= 0 && elapsed < 60_000) {
+      return repoHash;
+    }
     try {
       const params = new URLSearchParams({ repo: "bunny-lab-io/Borealis", branch: "main" });
-      const resp = await fetch(`/api/repo/current_hash?${params.toString()}`);
+      if (force) {
+        params.set("refresh", "1");
+      }
+      const resp = await fetch(`/api/agent/repo_hash?${params.toString()}`);
       const json = await resp.json();
       const sha = (json?.sha || "").trim();
       if (!resp.ok || !sha) {
@@ -158,14 +168,19 @@ export default function DeviceList({ onSelectDevice }) {
         err.response = json;
         throw err;
       }
-      setRepoHash((prev) => sha || prev || null);
+      lastRepoFetchRef.current = now;
+      setRepoHash((prev) => (sha ? sha : prev || null));
       return sha || null;
     } catch (err) {
       console.warn("Failed to fetch repository hash", err);
+      if (!force && repoHash) {
+        return repoHash;
+      }
+      lastRepoFetchRef.current = now;
       setRepoHash((prev) => prev || null);
       return null;
     }
-  }, []);
+  }, [repoHash]);
 
   const computeAgentVersion = useCallback((agentHashValue, repoHashValue) => {
     const agentHash = (agentHashValue || "").trim();
@@ -179,7 +194,7 @@ export default function DeviceList({ onSelectDevice }) {
     const { refreshRepo = false } = options || {};
     let repoSha = repoHash;
     if (refreshRepo || !repoSha) {
-      const fetched = await fetchLatestRepoHash();
+      const fetched = await fetchLatestRepoHash({ force: refreshRepo });
       if (fetched) repoSha = fetched;
     }
 
diff --git a/Data/Server/server.py b/Data/Server/server.py
index 6a424eb0..73577442 100644
--- a/Data/Server/server.py
+++ b/Data/Server/server.py
@@ -356,6 +356,44 @@ def health():
     return jsonify({"status": "ok"})
 
 
+@app.route("/api/agent/repo_hash", methods=["GET"])
+def api_agent_repo_hash():
+    try:
+        repo = (request.args.get('repo') or _DEFAULT_REPO).strip()
+        branch = (request.args.get('branch') or _DEFAULT_BRANCH).strip()
+        refresh_flag = (request.args.get('refresh') or '').strip().lower()
+        ttl_raw = request.args.get('ttl')
+        if '/' not in repo:
+            return jsonify({"error": "repo must be in the form owner/name"}), 400
+        try:
+            ttl = int(ttl_raw) if ttl_raw else _REPO_HASH_INTERVAL
+        except ValueError:
+            ttl = _REPO_HASH_INTERVAL
+        ttl = max(30, min(ttl, 3600))
+        force_refresh = refresh_flag in {'1', 'true', 'yes', 'force', 'refresh'}
+        if repo == _DEFAULT_REPO and branch == _DEFAULT_BRANCH:
+            result = _refresh_default_repo_hash(force=force_refresh)
+        else:
+            result = _fetch_repo_head(repo, branch, ttl_seconds=ttl, force_refresh=force_refresh)
+        sha = (result.get('sha') or '').strip()
+        payload = {
+            'repo': repo,
+            'branch': branch,
+            'sha': sha if sha else None,
+            'cached': bool(result.get('cached')),
+            'age_seconds': result.get('age_seconds'),
+            'source': result.get('source'),
+        }
+        if result.get('error'):
+            payload['error'] = result['error']
+        if sha:
+            return jsonify(payload)
+        return jsonify(payload), 503
+    except Exception as exc:
+        _write_service_log('server', f'/api/agent/repo_hash error: {exc}')
+        return jsonify({"error": "internal error"}), 500
+
+
 @app.route("/api/repo/current_hash", methods=["GET"])
 def api_repo_current_hash():
     try:

From 53cb3f41c58a038ee16542a7ea0db79f60c55b68 Mon Sep 17 00:00:00 2001
From: Nicole Rappe <nicole.rappe@bunny-lab.io>
Date: Wed, 8 Oct 2025 22:01:06 -0600
Subject: [PATCH 4/4] Remove legacy repo hash endpoint and update clients

---
 Data/Server/WebUI/src/Devices/Device_List.jsx |  2 +-
 Data/Server/server.py                         | 38 -------------------
 2 files changed, 1 insertion(+), 39 deletions(-)

diff --git a/Data/Server/WebUI/src/Devices/Device_List.jsx b/Data/Server/WebUI/src/Devices/Device_List.jsx
index 1be8e90c..a7ad04fe 100644
--- a/Data/Server/WebUI/src/Devices/Device_List.jsx
+++ b/Data/Server/WebUI/src/Devices/Device_List.jsx
@@ -160,7 +160,7 @@ export default function DeviceList({ onSelectDevice }) {
       if (force) {
         params.set("refresh", "1");
       }
-      const resp = await fetch(`/api/agent/repo_hash?${params.toString()}`);
+      const resp = await fetch(`/api/repo/current_hash?${params.toString()}`);
       const json = await resp.json();
       const sha = (json?.sha || "").trim();
       if (!resp.ok || !sha) {
diff --git a/Data/Server/server.py b/Data/Server/server.py
index 73577442..6a424eb0 100644
--- a/Data/Server/server.py
+++ b/Data/Server/server.py
@@ -356,44 +356,6 @@ def health():
     return jsonify({"status": "ok"})
 
 
-@app.route("/api/agent/repo_hash", methods=["GET"])
-def api_agent_repo_hash():
-    try:
-        repo = (request.args.get('repo') or _DEFAULT_REPO).strip()
-        branch = (request.args.get('branch') or _DEFAULT_BRANCH).strip()
-        refresh_flag = (request.args.get('refresh') or '').strip().lower()
-        ttl_raw = request.args.get('ttl')
-        if '/' not in repo:
-            return jsonify({"error": "repo must be in the form owner/name"}), 400
-        try:
-            ttl = int(ttl_raw) if ttl_raw else _REPO_HASH_INTERVAL
-        except ValueError:
-            ttl = _REPO_HASH_INTERVAL
-        ttl = max(30, min(ttl, 3600))
-        force_refresh = refresh_flag in {'1', 'true', 'yes', 'force', 'refresh'}
-        if repo == _DEFAULT_REPO and branch == _DEFAULT_BRANCH:
-            result = _refresh_default_repo_hash(force=force_refresh)
-        else:
-            result = _fetch_repo_head(repo, branch, ttl_seconds=ttl, force_refresh=force_refresh)
-        sha = (result.get('sha') or '').strip()
-        payload = {
-            'repo': repo,
-            'branch': branch,
-            'sha': sha if sha else None,
-            'cached': bool(result.get('cached')),
-            'age_seconds': result.get('age_seconds'),
-            'source': result.get('source'),
-        }
-        if result.get('error'):
-            payload['error'] = result['error']
-        if sha:
-            return jsonify(payload)
-        return jsonify(payload), 503
-    except Exception as exc:
-        _write_service_log('server', f'/api/agent/repo_hash error: {exc}')
-        return jsonify({"error": "internal error"}), 500
-
-
 @app.route("/api/repo/current_hash", methods=["GET"])
 def api_repo_current_hash():
     try: