diff --git a/backend/migrations/add_ivanti_findings_tables.js b/backend/migrations/add_ivanti_findings_tables.js
new file mode 100644
index 0000000..4b3fb83
--- /dev/null
+++ b/backend/migrations/add_ivanti_findings_tables.js
@@ -0,0 +1,58 @@
+// Migration: Add ivanti_findings_cache and ivanti_finding_notes tables
+const sqlite3 = require('sqlite3').verbose();
+const path = require('path');
+
+const dbPath = path.join(__dirname, '..', 'cve_database.db');
+const db = new sqlite3.Database(dbPath);
+
+console.log('Starting Ivanti findings tables migration...');
+
+db.serialize(() => {
+ // Cache table — single row holding the latest sync result
+ db.run(`
+ CREATE TABLE IF NOT EXISTS ivanti_findings_cache (
+ id INTEGER PRIMARY KEY CHECK (id = 1),
+ total INTEGER DEFAULT 0,
+ findings_json TEXT DEFAULT '[]',
+ synced_at DATETIME,
+ sync_status TEXT DEFAULT 'never',
+ error_message TEXT
+ )
+ `, (err) => {
+ if (err) console.error('Error creating findings cache table:', err);
+ else console.log('✓ ivanti_findings_cache table created');
+ });
+
+ db.run(`
+ INSERT OR IGNORE INTO ivanti_findings_cache (id, total, findings_json, sync_status)
+ VALUES (1, 0, '[]', 'never')
+ `, (err) => {
+ if (err) console.error('Error seeding findings cache row:', err);
+ else console.log('✓ ivanti_findings_cache row seeded');
+ });
+
+ // Notes table — one row per finding, persists across cache refreshes
+ db.run(`
+ CREATE TABLE IF NOT EXISTS ivanti_finding_notes (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ finding_id TEXT NOT NULL UNIQUE,
+ note TEXT NOT NULL DEFAULT '',
+ updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+ )
+ `, (err) => {
+ if (err) console.error('Error creating finding notes table:', err);
+ else console.log('✓ ivanti_finding_notes table created');
+ });
+
+ db.run(`
+ CREATE INDEX IF NOT EXISTS idx_finding_notes_finding_id
+ ON ivanti_finding_notes(finding_id)
+ `, (err) => {
+ if (err) console.error('Error creating notes index:', err);
+ else console.log('✓ finding_id index created');
+ });
+});
+
+db.close(() => {
+ console.log('Migration complete!');
+});
diff --git a/backend/routes/ivantiFindings.js b/backend/routes/ivantiFindings.js
new file mode 100644
index 0000000..5fa7e94
--- /dev/null
+++ b/backend/routes/ivantiFindings.js
@@ -0,0 +1,320 @@
+// Ivanti / RiskSense Host Findings Routes
+// Caches hostFinding/search results in SQLite with daily auto-sync.
+// Notes are stored separately so they survive cache refreshes.
+
+const express = require('express');
+const https = require('https');
+
+const IVANTI_URL_BASE = 'https://platform4.risksense.com/api/v1';
+const SYNC_INTERVAL_MS = 24 * 60 * 60 * 1000;
+
+const FINDINGS_FILTERS = [
+ {
+ field: 'assetCustomAttributes.1550_host_1.value',
+ exclusive: false,
+ operator: 'IN',
+ orWithPrevious: false,
+ implicitFilters: [],
+ value: 'NTS-AEO-ACCESS-ENG,NTS-AEO-STEAM',
+ caseSensitive: false
+ },
+ {
+ field: 'severity',
+ exclusive: false,
+ operator: 'RANGE',
+ orWithPrevious: false,
+ implicitFilters: [],
+ value: '8.5,9.9',
+ caseSensitive: false
+ },
+ {
+ field: 'generic_state',
+ exclusive: false,
+ operator: 'EXACT',
+ orWithPrevious: false,
+ implicitFilters: [],
+ value: 'Open',
+ caseSensitive: false
+ }
+];
+
+// ---------------------------------------------------------------------------
+// HTTP helper — mirrors the one in ivantiWorkflows.js
+// ---------------------------------------------------------------------------
+function ivantiPost(urlPath, body, apiKey, skipTls) {
+ const bodyStr = JSON.stringify(body);
+ const fullUrl = new URL(IVANTI_URL_BASE + urlPath);
+
+ return new Promise((resolve, reject) => {
+ const options = {
+ hostname: fullUrl.hostname,
+ path: fullUrl.pathname + fullUrl.search,
+ method: 'POST',
+ headers: {
+ 'accept': '*/*',
+ 'content-type': 'application/json',
+ 'x-api-key': apiKey,
+ 'x-http-client-type': 'browser',
+ 'content-length': Buffer.byteLength(bodyStr)
+ },
+ rejectUnauthorized: !skipTls,
+ timeout: 20000
+ };
+
+ const req = https.request(options, (res) => {
+ let data = '';
+ res.on('data', (chunk) => { data += chunk; });
+ res.on('end', () => resolve({ status: res.statusCode, body: data }));
+ });
+
+ req.on('timeout', () => req.destroy(new Error('Request timed out')));
+ req.on('error', reject);
+ req.write(bodyStr);
+ req.end();
+ });
+}
+
+// ---------------------------------------------------------------------------
+// Table init
+// ---------------------------------------------------------------------------
+function initTables(db) {
+ return new Promise((resolve, reject) => {
+ db.serialize(() => {
+ db.run(`
+ CREATE TABLE IF NOT EXISTS ivanti_findings_cache (
+ id INTEGER PRIMARY KEY CHECK (id = 1),
+ total INTEGER DEFAULT 0,
+ findings_json TEXT DEFAULT '[]',
+ synced_at DATETIME,
+ sync_status TEXT DEFAULT 'never',
+ error_message TEXT
+ )
+ `, (err) => { if (err) return reject(err); });
+
+ db.run(`
+ INSERT OR IGNORE INTO ivanti_findings_cache (id, total, findings_json, sync_status)
+ VALUES (1, 0, '[]', 'never')
+ `, (err) => { if (err) return reject(err); });
+
+ db.run(`
+ CREATE TABLE IF NOT EXISTS ivanti_finding_notes (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ finding_id TEXT NOT NULL UNIQUE,
+ note TEXT NOT NULL DEFAULT '',
+ updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+ )
+ `, (err) => { if (err) return reject(err); });
+
+ db.run(`
+ CREATE INDEX IF NOT EXISTS idx_finding_notes_finding_id
+ ON ivanti_finding_notes(finding_id)
+ `, (err) => {
+ if (err) reject(err);
+ else resolve();
+ });
+ });
+ });
+}
+
+// ---------------------------------------------------------------------------
+// Extract only the fields we need from a raw finding object
+// ---------------------------------------------------------------------------
+function extractFinding(f) {
+ // statusEmbedded.dueDate = "2026-03-06T00:00:00" — strip to date part
+ const rawDueDate = f.statusEmbedded?.dueDate || '';
+ const dueDate = rawDueDate ? rawDueDate.split('T')[0] : '';
+
+ // BU ownership: assetCustomAttributes['1550_host_1'] is an array like ["NTS-AEO-STEAM"]
+ const buOwnership = f.assetCustomAttributes?.['1550_host_1']?.[0] || '';
+
+ return {
+ id: String(f.id),
+ title: f.title || '',
+ severity: typeof f.severity === 'number' ? f.severity : parseFloat(f.severity) || 0,
+ vrrGroup: f.vrrGroup || f.severityGroup || '',
+ hostName: f.host?.hostName || '',
+ ipAddress: f.host?.ipAddress || '',
+ dns: f.dns || f.host?.fqdn || '',
+ status: f.status || '',
+ slaStatus: f.slaStatus || '',
+ dueDate,
+ lastFoundOn: f.lastFoundOn || '',
+ buOwnership
+ };
+}
+
+// ---------------------------------------------------------------------------
+// Core sync — fetches ALL pages, stores slimmed findings in SQLite
+// ---------------------------------------------------------------------------
+async function syncFindings(db) {
+ const apiKey = process.env.IVANTI_API_KEY;
+ const clientId = process.env.IVANTI_CLIENT_ID || '1550';
+ const skipTls = process.env.IVANTI_SKIP_TLS === 'true';
+
+ if (!apiKey) {
+ const errMsg = 'IVANTI_API_KEY not set in .env — skipping sync';
+ console.warn('[Ivanti Findings]', errMsg);
+ await dbRun(db, `UPDATE ivanti_findings_cache SET sync_status='error', error_message=?, synced_at=datetime('now') WHERE id=1`, [errMsg]);
+ return;
+ }
+
+ console.log('[Ivanti Findings] Starting sync...');
+
+ const urlPath = `/client/${encodeURIComponent(clientId)}/hostFinding/search`;
+ let allFindings = [];
+ let page = 0;
+ let totalPages = 1;
+
+ try {
+ do {
+ const body = {
+ filters: FINDINGS_FILTERS,
+ projection: 'internal',
+ sort: [{ field: 'severity', direction: 'ASC' }],
+ page,
+ size: 100
+ };
+
+ const result = await ivantiPost(urlPath, body, apiKey, skipTls);
+
+ if (result.status === 401) throw new Error('Invalid or missing API key (401)');
+ if (result.status === 419) throw new Error('Insufficient privileges (419) — API key lacks hostFinding access');
+ if (result.status === 429) throw new Error('Rate limited (429) — try again later');
+ if (result.status !== 200) throw new Error(`Ivanti API returned status ${result.status}`);
+
+ const data = JSON.parse(result.body);
+ totalPages = data.page?.totalPages || 1;
+ const findings = data._embedded?.hostFindings || [];
+ allFindings = allFindings.concat(findings.map(extractFinding));
+
+ console.log(`[Ivanti Findings] Page ${page + 1}/${totalPages} — ${allFindings.length} findings so far`);
+ page++;
+ } while (page < totalPages);
+
+ await dbRun(db,
+ `UPDATE ivanti_findings_cache SET total=?, findings_json=?, synced_at=datetime('now'), sync_status='success', error_message=NULL WHERE id=1`,
+ [allFindings.length, JSON.stringify(allFindings)]
+ );
+
+ console.log(`[Ivanti Findings] Sync complete — ${allFindings.length} findings`);
+ } catch (err) {
+ const msg = err.message || 'Unknown error';
+ console.error('[Ivanti Findings] Sync failed:', msg);
+ await dbRun(db, `UPDATE ivanti_findings_cache SET sync_status='error', error_message=?, synced_at=datetime('now') WHERE id=1`, [msg]);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Scheduler
+// ---------------------------------------------------------------------------
+function scheduleSync(db) {
+ db.get('SELECT synced_at FROM ivanti_findings_cache WHERE id = 1', (err, row) => {
+ if (err || !row || !row.synced_at) {
+ syncFindings(db);
+ } else {
+ const lastSync = new Date(row.synced_at.replace(' ', 'T') + 'Z');
+ const hoursSince = (Date.now() - lastSync.getTime()) / (1000 * 60 * 60);
+ if (hoursSince >= 24) {
+ syncFindings(db);
+ } else {
+ console.log(`[Ivanti Findings] Last sync ${hoursSince.toFixed(1)}h ago — next auto-sync in ${(24 - hoursSince).toFixed(1)}h`);
+ }
+ }
+ });
+
+ setInterval(() => syncFindings(db), SYNC_INTERVAL_MS);
+}
+
+// ---------------------------------------------------------------------------
+// DB helpers
+// ---------------------------------------------------------------------------
+function dbRun(db, sql, params = []) {
+ return new Promise((resolve, reject) => {
+ db.run(sql, params, (err) => { if (err) reject(err); else resolve(); });
+ });
+}
+
+function readState(db) {
+ return new Promise((resolve, reject) => {
+ db.get(
+ 'SELECT total, findings_json, synced_at, sync_status, error_message FROM ivanti_findings_cache WHERE id = 1',
+ (err, row) => {
+ if (err) return reject(err);
+ if (!row) return resolve({ total: 0, findings: [], synced_at: null, sync_status: 'never', error_message: null });
+ let findings = [];
+ try { findings = JSON.parse(row.findings_json || '[]'); } catch (_) { /* leave empty */ }
+ resolve({ total: row.total || 0, findings, synced_at: row.synced_at, sync_status: row.sync_status, error_message: row.error_message });
+ }
+ );
+ });
+}
+
+function readNotes(db) {
+ return new Promise((resolve, reject) => {
+ db.all('SELECT finding_id, note FROM ivanti_finding_notes', (err, rows) => {
+ if (err) return reject(err);
+ const map = {};
+ (rows || []).forEach((r) => { map[r.finding_id] = r.note; });
+ resolve(map);
+ });
+ });
+}
+
+async function readStateWithNotes(db) {
+ const [state, notes] = await Promise.all([readState(db), readNotes(db)]);
+ state.findings = state.findings.map((f) => ({ ...f, note: notes[f.id] || '' }));
+ return state;
+}
+
+// ---------------------------------------------------------------------------
+// Router
+// ---------------------------------------------------------------------------
+function createIvantiFindingsRouter(db, requireAuth) {
+ const router = express.Router();
+
+ initTables(db)
+ .then(() => scheduleSync(db))
+ .catch((err) => console.error('[Ivanti Findings] Init failed:', err));
+
+ router.use(requireAuth(db));
+
+ // GET / — cached findings with notes merged in
+ router.get('/', async (req, res) => {
+ try {
+ res.json(await readStateWithNotes(db));
+ } catch {
+ res.status(500).json({ error: 'Database error reading findings' });
+ }
+ });
+
+ // POST /sync — trigger immediate sync, return fresh state
+ router.post('/sync', async (req, res) => {
+ await syncFindings(db);
+ try {
+ res.json(await readStateWithNotes(db));
+ } catch {
+ res.status(500).json({ error: 'Sync ran but could not read updated state' });
+ }
+ });
+
+ // PUT /:findingId/note — save or update a note (max 255 chars enforced here)
+ router.put('/:findingId/note', (req, res) => {
+ const { findingId } = req.params;
+ const note = String(req.body.note || '').slice(0, 255);
+
+ db.run(
+ `INSERT INTO ivanti_finding_notes (finding_id, note, updated_at)
+ VALUES (?, ?, datetime('now'))
+ ON CONFLICT(finding_id) DO UPDATE SET note=excluded.note, updated_at=datetime('now')`,
+ [findingId, note],
+ (err) => {
+ if (err) return res.status(500).json({ error: 'Failed to save note' });
+ res.json({ finding_id: findingId, note });
+ }
+ );
+ });
+
+ return router;
+}
+
+module.exports = createIvantiFindingsRouter;
diff --git a/backend/server.js b/backend/server.js
index ec9c0a7..02bfd4f 100644
--- a/backend/server.js
+++ b/backend/server.js
@@ -21,6 +21,7 @@ const createNvdLookupRouter = require('./routes/nvdLookup');
const createKnowledgeBaseRouter = require('./routes/knowledgeBase');
const createArcherTicketsRouter = require('./routes/archerTickets');
const createIvantiWorkflowsRouter = require('./routes/ivantiWorkflows');
+const createIvantiFindingsRouter = require('./routes/ivantiFindings');
const app = express();
const PORT = process.env.PORT || 3001;
@@ -183,6 +184,9 @@ app.use('/api/archer-tickets', createArcherTicketsRouter(db));
// Ivanti / RiskSense workflow routes (all authenticated users)
app.use('/api/ivanti/workflows', createIvantiWorkflowsRouter(db, requireAuth));
+// Ivanti / RiskSense host findings routes (all authenticated users)
+app.use('/api/ivanti/findings', createIvantiFindingsRouter(db, requireAuth));
+
// ========== CVE ENDPOINTS ==========
// Get all CVEs with optional filters (authenticated users)
diff --git a/frontend/src/components/pages/ReportingPage.js b/frontend/src/components/pages/ReportingPage.js
index 831c472..43712cb 100644
--- a/frontend/src/components/pages/ReportingPage.js
+++ b/frontend/src/components/pages/ReportingPage.js
@@ -1,25 +1,861 @@
-import React from 'react';
-import { BarChart2 } from 'lucide-react';
+import React, { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+import ReactDOM from 'react-dom';
+import { RefreshCw, Loader, AlertCircle, PieChart, ChevronUp, ChevronDown, ChevronsUpDown, Settings2, GripVertical, Eye, EyeOff, Filter } from 'lucide-react';
-export default function ReportingPage() {
- return (
-
-
-
-
-
-
- Reporting
-
-
- Under construction — coming soon
-
-
-
+ setValue(e.target.value)}
+ onBlur={save}
+ placeholder="Add note…"
+ style={{
+ width: '100%', minWidth: '160px',
+ background: 'rgba(14,165,233,0.05)',
+ border: '1px solid rgba(14,165,233,0.2)',
+ borderRadius: '4px', padding: '4px 8px',
+ color: '#CBD5E1', fontSize: '0.75rem',
+ fontFamily: 'inherit', outline: 'none', boxSizing: 'border-box'
+ }}
+ onFocus={(e) => { e.target.style.borderColor = 'rgba(14,165,233,0.6)'; e.target.style.background = 'rgba(14,165,233,0.1)'; }}
+ onBlurCapture={(e) => { e.target.style.borderColor = 'rgba(14,165,233,0.2)'; e.target.style.background = 'rgba(14,165,233,0.05)'; }}
+ />
+ {saving && }
+
+ );
+}
+
+// ---------------------------------------------------------------------------
+// ColumnManager — popover with drag-to-reorder and show/hide toggles
+// ---------------------------------------------------------------------------
+function ColumnManager({ columnOrder, onChange }) {
+ const [open, setOpen] = useState(false);
+ const [dragIdx, setDragIdx] = useState(null);
+ const [overIdx, setOverIdx] = useState(null);
+ const panelRef = useRef(null);
+ const btnRef = useRef(null);
+
+ useEffect(() => {
+ if (!open) return;
+ const handler = (e) => {
+ if (!panelRef.current?.contains(e.target) && !btnRef.current?.contains(e.target)) setOpen(false);
+ };
+ document.addEventListener('mousedown', handler);
+ return () => document.removeEventListener('mousedown', handler);
+ }, [open]);
+
+ const toggleVisible = (key) => {
+ onChange(columnOrder.map((c) => c.key === key ? { ...c, visible: !c.visible } : c));
+ };
+
+ const handleDragStart = (idx) => setDragIdx(idx);
+ const handleDragOver = (e, idx) => { e.preventDefault(); setOverIdx(idx); };
+ const handleDrop = (idx) => {
+ if (dragIdx === null || dragIdx === idx) { setDragIdx(null); setOverIdx(null); return; }
+ const updated = [...columnOrder];
+ const [moved] = updated.splice(dragIdx, 1);
+ updated.splice(idx, 0, moved);
+ onChange(updated);
+ setDragIdx(null);
+ setOverIdx(null);
+ };
+
+ const visibleCount = columnOrder.filter((c) => c.visible).length;
+
+ return (
+
+
+
+ {open && (
+
+
+ Drag to reorder · click to toggle
+
+ {columnOrder.map((col, idx) => {
+ const def = COLUMN_DEFS[col.key];
+ const isDragging = dragIdx === idx;
+ const isOver = overIdx === idx && dragIdx !== null && dragIdx !== idx;
+ return (
+
handleDragStart(idx)}
+ onDragOver={(e) => handleDragOver(e, idx)}
+ onDrop={() => handleDrop(idx)}
+ onDragEnd={() => { setDragIdx(null); setOverIdx(null); }}
+ style={{
+ display: 'flex', alignItems: 'center', gap: '0.5rem',
+ padding: '0.4rem 0.5rem', borderRadius: '0.25rem', cursor: 'grab',
+ opacity: isDragging ? 0.4 : 1,
+ background: isOver ? 'rgba(14,165,233,0.12)' : 'transparent',
+ borderTop: isOver ? '2px solid #0EA5E9' : '2px solid transparent',
+ transition: 'background 0.1s'
+ }}
+ >
+
+
+ {def?.label || col.key}
+
+
+
+ );
+ })}
+
+ )}
+
+ {/* Search */}
+
setSearch(e.target.value)}
+ placeholder="Search values…"
+ style={{
+ width: '100%', marginBottom: '0.375rem',
+ background: 'rgba(14,165,233,0.05)',
+ border: '1px solid rgba(14,165,233,0.2)',
+ borderRadius: '0.25rem', padding: '0.3rem 0.5rem',
+ color: '#CBD5E1', fontSize: '0.72rem',
+ fontFamily: 'monospace', outline: 'none', boxSizing: 'border-box',
+ }}
+ />
+
+ {/* Select All / Clear */}
+
+
+
+
+
+ {/* Value checkboxes */}
+
+ {displayed.length === 0 ? (
+
No values
+ ) : displayed.map((val) => (
+
+ ))}
+
+
+ {/* Status footer */}
+
+ {activeCount} / {allValues.length} selected
+
+
+
+ {finding.severity?.toFixed(2)}
+ {finding.vrrGroup}
+
+ |
+ );
+ }
+ case 'title':
+ return (
+
+
+ {finding.title}
+
+ |
+ );
+ case 'hostName':
+ case 'ipAddress':
+ return (
+
+ {finding[colKey] || '—'}
+ |
+ );
+ case 'dns':
+ return (
+
+
+ {finding.dns || '—'}
+
+ |
+ );
+ case 'dueDate': {
+ const color = dueDateColor(finding.dueDate);
+ return (
+
+ {finding.dueDate || '—'}
+ |
+ );
+ }
+ case 'slaStatus':
+ return (
+
+ {finding.slaStatus || '—'}
+ |
+ );
+ case 'buOwnership': {
+ const bu = finding.buOwnership || '';
+ const isSteam = bu.toUpperCase().includes('STEAM');
+ return (
+
+ {bu ? (
+
+ {bu.replace('NTS-AEO-', '')}
+
+ ) : (
+ —
+ )}
+ |
+ );
+ }
+ case 'lastFoundOn':
+ return (
+
+ {finding.lastFoundOn || '—'}
+ |
+ );
+ case 'note':
+ return (
+
+
+ |
+ );
+ default:
+ return — | ;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Main ReportingPage
+// ---------------------------------------------------------------------------
+export default function ReportingPage() {
+ const [findings, setFindings] = useState([]);
+ const [total, setTotal] = useState(null);
+ const [syncedAt, setSyncedAt] = useState(null);
+ const [syncStatus, setSyncStatus] = useState(null);
+ const [syncError, setSyncError] = useState(null);
+ const [loading, setLoading] = useState(false);
+ const [syncing, setSyncing] = useState(false);
+ const [sort, setSort] = useState({ field: 'severity', dir: 'desc' });
+ const [columnOrder, setColumnOrder] = useState(loadColumnOrder);
+ const [columnFilters, setColumnFilters] = useState({});
+ const [openFilter, setOpenFilter] = useState(null);
+ const filterBtnRefs = useRef({});
+
+ const updateColumns = useCallback((newOrder) => {
+ setColumnOrder(newOrder);
+ saveColumnOrder(newOrder);
+ }, []);
+
+ const applyState = (data) => {
+ setTotal(data.total ?? 0);
+ setFindings(data.findings || []);
+ setSyncedAt(data.synced_at || null);
+ setSyncStatus(data.sync_status || null);
+ setSyncError(data.error_message || null);
+ };
+
+ const fetchFindings = async () => {
+ setLoading(true);
+ try {
+ const res = await fetch(`${API_BASE}/ivanti/findings`, { credentials: 'include' });
+ const data = await res.json();
+ if (res.ok) applyState(data);
+ } catch (e) {
+ console.error('Error loading findings:', e);
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ const syncFindings = async () => {
+ setSyncing(true);
+ try {
+ const res = await fetch(`${API_BASE}/ivanti/findings/sync`, { method: 'POST', credentials: 'include' });
+ const data = await res.json();
+ if (res.ok) applyState(data);
+ } catch (e) {
+ console.error('Error syncing findings:', e);
+ } finally {
+ setSyncing(false);
+ }
+ };
+
+ useEffect(() => { fetchFindings(); }, []); // eslint-disable-line
+
+ // Set/clear a single column filter
+ const setColFilter = useCallback((colKey, vals) => {
+ setColumnFilters((prev) => {
+ if (!vals) {
+ const next = { ...prev };
+ delete next[colKey];
+ return next;
+ }
+ return { ...prev, [colKey]: vals };
+ });
+ }, []);
+
+ // Apply all active column filters to produce the visible row set
+ const filtered = useMemo(() => {
+ const active = Object.entries(columnFilters);
+ if (active.length === 0) return findings;
+ return findings.filter((f) =>
+ active.every(([key, vals]) => {
+ if (!vals || vals.size === 0) return false;
+ return vals.has(getFilterVal(f, key).trim());
+ })
+ );
+ }, [findings, columnFilters]);
+
+ // Visible columns in current order
+ const visibleCols = columnOrder.filter((c) => c.visible && COLUMN_DEFS[c.key]);
+
+ // Sort filtered results
+ const sorted = useMemo(() => [...filtered].sort((a, b) => {
+ const av = getVal(a, sort.field);
+ const bv = getVal(b, sort.field);
+ let cmp = 0;
+ if (typeof av === 'number' && typeof bv === 'number') {
+ cmp = av - bv;
+ } else {
+ cmp = String(av).localeCompare(String(bv), undefined, { numeric: true });
+ }
+ return sort.dir === 'asc' ? cmp : -cmp;
+ }), [filtered, sort]);
+
+ const toggleSort = (key) => {
+ setSort((prev) =>
+ prev.field === key
+ ? { field: key, dir: prev.dir === 'asc' ? 'desc' : 'asc' }
+ : { field: key, dir: 'asc' }
+ );
+ };
+
+ const activeFilterCount = Object.keys(columnFilters).length;
+
+ const syncedDisplay = syncedAt
+ ? `Synced ${new Date(syncedAt.replace(' ', 'T') + 'Z').toLocaleString()}`
+ : 'Never synced';
+
+ // -------------------------------------------------------------------------
+ // Render
+ // -------------------------------------------------------------------------
+ return (
+
+
+ {/* ----------------------------------------------------------------
+ Panel 1 — Metrics placeholder
+ ---------------------------------------------------------------- */}
+
+
+
+
+ Pie charts & metrics — coming soon
+
+
+
+
+ {/* ----------------------------------------------------------------
+ Panel 2 — Findings table
+ ---------------------------------------------------------------- */}
+
+ {/* Panel header */}
+
+
+
+ Host Findings
+
+
+ {syncedDisplay}
+ {syncStatus === 'success' && total !== null && (
+
+ {activeFilterCount > 0 ? `${filtered.length} of ${total}` : total} findings
+ {activeFilterCount > 0 && (
+
+ ({activeFilterCount} filter{activeFilterCount > 1 ? 's' : ''} active)
+
+ )}
+
+ )}
+
+
+
+ {/* Action buttons */}
+
+ {activeFilterCount > 0 && (
+
+ )}
+
+
+
+
+
+ {/* Error banner */}
+ {syncStatus === 'error' && syncError && (
+
+ )}
+
+ {/* Content */}
+ {loading ? (
+
+ ) : syncStatus === 'never' ? (
+
+
Click Sync to load findings data
+
+ ) : (
+
+
+
+
+ {visibleCols.map((col) => {
+ const def = COLUMN_DEFS[col.key];
+ const active = sort.field === col.key;
+ const isFiltered = !!columnFilters[col.key];
+ return (
+ | toggleSort(col.key) : undefined}
+ style={{
+ padding: '0.5rem 0.75rem', textAlign: 'left',
+ fontFamily: 'monospace', fontSize: '0.68rem', fontWeight: '600',
+ color: active ? '#0EA5E9' : '#64748B',
+ textTransform: 'uppercase', letterSpacing: '0.08em',
+ whiteSpace: 'nowrap',
+ cursor: def?.sortable ? 'pointer' : 'default',
+ userSelect: 'none',
+ background: 'rgba(15,26,46,0.6)',
+ position: 'relative',
+ }}
+ >
+
+ {def?.label || col.key}
+ {def?.sortable && }
+ {def?.filterable && (
+
+ )}
+
+ |
+ );
+ })}
+
+
+
+ {sorted.map((finding, idx) => {
+ const rowBg = idx % 2 === 0 ? 'rgba(15,26,46,0.4)' : 'rgba(10,18,32,0.4)';
+ return (
+ e.currentTarget.style.background = 'rgba(14,165,233,0.05)'}
+ onMouseLeave={(e) => e.currentTarget.style.background = rowBg}
+ >
+ {visibleCols.map((col) => (
+
+ ))}
+
+ );
+ })}
+ {sorted.length === 0 && (
+
+ |
+ {activeFilterCount > 0 ? 'No findings match the current filters' : 'No findings found'}
+ |
+
+ )}
+
+
+
+ )}
+
+
+ {/* Filter dropdown — rendered via portal at document.body */}
+ {openFilter && COLUMN_DEFS[openFilter]?.filterable && (
+
setColFilter(openFilter, vals)}
+ onClose={() => setOpenFilter(null)}
+ />
+ )}
+