@cybermem/dashboard 0.5.6 → 0.5.8

package/app/api/audit-logs/route.ts

@@ -1,10 +1,35 @@
+import fs from 'fs'
 import { NextResponse } from 'next/server'
+import path from 'path'
 
 export const dynamic = 'force-dynamic'
 
 // Use env var for db-exporter URL (Docker internal vs local dev)
 const DB_EXPORTER_URL = process.env.DB_EXPORTER_URL || 'http://localhost:8000'
 
+// Load clients config for name normalization
+let clientsConfig: any[] = []
+try {
+  const configPath = path.join(process.cwd(), 'public', 'clients.json')
+  clientsConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+} catch (e) {
+  console.error('Failed to load clients.json:', e)
+}
+
+// Normalize raw client name (e.g. "antigravity-client") to friendly name (e.g. "Antigravity")
+function normalizeClientName(rawName: string): string {
+  if (!rawName) return 'Unknown'
+  const nameLower = rawName.toLowerCase()
+  const client = clientsConfig.find((c: any) => {
+    try {
+      return new RegExp(c.match, 'i').test(nameLower)
+    } catch {
+      return nameLower.includes(c.match)
+    }
+  })
+  return client?.name || rawName
+}
+
 const CLIENTS = ["Claude Code", "v0", "Cursor", "GitHub Copilot", "Windsurf"]
 const OPERATIONS = ["Read", "Write", "Update", "Delete", "Create"]
 const STATUSES = ["Success", "Success", "Success", "Warning", "Error"]
@@ -45,7 +70,7 @@ export async function GET(request: Request) {
 
         return {
             timestamp: log.timestamp,
-            client: log.client_name || "Unknown",
+            client: normalizeClientName(log.client_name),
             operation: operation,
             status: status,
             method: log.method,

package/app/api/backup/route.ts

@@ -0,0 +1,67 @@
+import { exec } from 'child_process'
+import { createReadStream, statSync } from 'fs'
+import { NextResponse } from 'next/server'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { promisify } from 'util'
+
+export const dynamic = 'force-dynamic'
+
+const execAsync = promisify(exec)
+
+/**
+ * GET /api/backup
+ * Creates and downloads a backup of the OpenMemory database
+ */
+export async function GET() {
+  try {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+    const backupName = `cybermem-backup-${timestamp}.tar.gz`
+    const tmpPath = join(tmpdir(), backupName)
+
+    // Create backup via docker
+    const containerName = process.env.OPENMEMORY_CONTAINER || 'cybermem-openmemory'
+
+    try {
+      // Copy data from container to temp location
+      await execAsync(
+        `docker cp ${containerName}:/data - | gzip > "${tmpPath}"`
+      )
+
+      // Get file stats
+      const stats = statSync(tmpPath)
+
+      // Stream the file
+      const stream = createReadStream(tmpPath)
+
+      // Convert Node stream to Web ReadableStream
+      const webStream = new ReadableStream({
+        start(controller) {
+          stream.on('data', (chunk) => controller.enqueue(chunk))
+          stream.on('end', () => controller.close())
+          stream.on('error', (err) => controller.error(err))
+        }
+      })
+
+      return new NextResponse(webStream, {
+        headers: {
+          'Content-Type': 'application/gzip',
+          'Content-Disposition': `attachment; filename="${backupName}"`,
+          'Content-Length': String(stats.size)
+        }
+      })
+
+    } catch (dockerError: any) {
+      return NextResponse.json(
+        { error: `Backup failed: ${dockerError.message}` },
+        { status: 500 }
+      )
+    }
+
+  } catch (error: any) {
+    return NextResponse.json(
+      { error: error.message || 'Unknown error' },
+      { status: 500 }
+    )
+  }
+}

package/app/api/metrics/route.ts

@@ -1,137 +1,121 @@
-import {
-    getClientCount,
-    getCreatesByClient,
-    getDeletesByClient,
-    getErrorsByClient,
-    getLastReader,
-    getLastWriter,
-    getMemoryRecordsCount,
-    getMemoryRecordsSparkline,
-    getReadsByClient,
-    getRequestsByClient,
-    getRequestsByMethod,
-    getRequestsTimeSeries,
-    getRequestsTimeSeriesByMethod,
-    getResponseTimeTimeSeries,
-    getSuccessRate,
-    getSuccessRateByClient,
-    getSuccessRateSparkline,
-    getSuccessRateTimeSeries,
-    getSuccessRateTimeSeriesByClient,
-    getTopReader,
-    getTopWriter,
-    getTotalClientsSparkline,
-    getTotalRequests,
-    getTotalRequestsSparkline,
-    getUpdatesByClient
-} from '@/lib/prometheus'
+import fs from 'fs'
 import { NextResponse } from 'next/server'
+import path from 'path'
 
 export const dynamic = 'force-dynamic'
 export const revalidate = 0
 
+// Use env var for db-exporter URL (Docker internal vs local dev)
+const DB_EXPORTER_URL = process.env.DB_EXPORTER_URL || 'http://localhost:8000'
+
+// Load clients config for name normalization
+let clientsConfig: any[] = []
+try {
+  const configPath = path.join(process.cwd(), 'public', 'clients.json')
+  clientsConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+} catch (e) {
+  console.error('Failed to load clients.json:', e)
+}
+
+// Normalize raw client name to friendly name
+function normalizeClientName(rawName: string): string {
+  if (!rawName || rawName === 'N/A') return rawName
+  const nameLower = rawName.toLowerCase()
+  const client = clientsConfig.find((c: any) => {
+    try {
+      return new RegExp(c.match, 'i').test(nameLower)
+    } catch {
+      return nameLower.includes(c.match)
+    }
+  })
+  return client?.name || rawName
+}
+
+// Normalize client names in time series data
+function normalizeTimeSeries(data: any[]): any[] {
+  return data.map(point => {
+    const normalized: any = { time: point.time }
+    for (const [key, value] of Object.entries(point)) {
+      if (key !== 'time') {
+        normalized[normalizeClientName(key)] = value
+      }
+    }
+    return normalized
+  })
+}
+
 export async function GET(request: Request) {
   try {
     const { searchParams } = new URL(request.url)
-    const period = searchParams.get('period') || '15m'
+    const period = searchParams.get('period') || '24h'
+
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), 5000)
 
-    const [
-      totalRequests,
-      requestsByClient,
-      requestsByMethod,
-      successRate,
-      requestsTimeSeries,
-      responseTimeTimeSeries,
-      successRateTimeSeries,
-      writesTimeSeries,
-      memoryRecords,
-      clientCount,
-      memoryRecordsSparkline,
-      totalRequestsSparkline,
-      totalClientsSparkline,
-      successRateSparkline,
-      successRateByClient,
-      successRateTimeSeriesByClient,
-      topWriter,
-      topReader,
-      lastWriter,
-      lastReader,
-      createsTimeSeries,
-      readsTimeSeries,
-      updatesTimeSeries,
-      deletesTimeSeries,
-      errorsTimeSeries
-    ] = await Promise.all([
-      getTotalRequests(period),
-      getRequestsByClient(period),
-      getRequestsByMethod(period),
-      getSuccessRate(),
-      getRequestsTimeSeries(period),
-      getResponseTimeTimeSeries(period),
-      getSuccessRateTimeSeries(period),
-      getRequestsTimeSeriesByMethod('POST', period),
-      getMemoryRecordsCount(),
-      getClientCount(),
-      getMemoryRecordsSparkline(period),
-      getTotalRequestsSparkline(period),
-      getTotalClientsSparkline(period),
-      getSuccessRateSparkline(period),
-      getSuccessRateByClient(),
-      getSuccessRateTimeSeriesByClient(period),
-      getTopWriter(),
-      getTopReader(),
-      getLastWriter(),
-      getLastReader(),
-      getCreatesByClient(period),
-      getReadsByClient(period),
-      getUpdatesByClient(period),
-      getDeletesByClient(period),
-      getErrorsByClient(period)
+    // Fetch stats and timeseries from db-exporter (SQLite)
+    const [statsRes, timeseriesRes] = await Promise.all([
+      fetch(`${DB_EXPORTER_URL}/api/stats`, {
+        signal: controller.signal,
+        cache: 'no-store'
+      }),
+      fetch(`${DB_EXPORTER_URL}/api/timeseries?period=${period}`, {
+        signal: controller.signal,
+        cache: 'no-store'
+      })
     ])
 
-    // Sort clients by total requests
-    const clientStats = Object.entries(requestsByClient)
-      .map(([client, total]) => ({
-        client,
-        total,
-        reads: requestsByMethod.reads[client] || 0,
-        writes: requestsByMethod.writes[client] || 0
-      }))
-      .sort((a, b) => b.total - a.total)
+    clearTimeout(timeoutId)
 
-    return NextResponse.json({
-      stats: {
-        memoryRecords,
-        totalClients: clientCount,
-        successRate,
-        totalRequests,
-        topWriter,
-        topReader,
-        lastWriter,
-        lastReader
+    if (!statsRes.ok) {
+      throw new Error(`Failed to fetch stats: ${statsRes.statusText}`)
+    }
+
+    const stats = await statsRes.json()
+    const timeseries = timeseriesRes.ok ? await timeseriesRes.json() : { creates: [], reads: [], updates: [], deletes: [] }
+
+    // Normalize client names
+    const normalizedStats = {
+      memoryRecords: stats.memoryRecords || 0,
+      totalClients: stats.totalClients || 0,
+      successRate: stats.successRate || 100,
+      totalRequests: stats.totalRequests || 0,
+      topWriter: {
+        name: normalizeClientName(stats.topWriter?.name || 'N/A'),
+        count: stats.topWriter?.count || 0
       },
-      timeSeries: {
-        requests: requestsTimeSeries,
-        responseTime: responseTimeTimeSeries,
-        successRate: successRateTimeSeries,
-        successRateByClient: successRateTimeSeriesByClient,
-        writes: writesTimeSeries,
-        creates: createsTimeSeries,
-        reads: readsTimeSeries,
-        updates: updatesTimeSeries,
-        deletes: deletesTimeSeries,
-        errors: errorsTimeSeries
+      topReader: {
+        name: normalizeClientName(stats.topReader?.name || 'N/A'),
+        count: stats.topReader?.count || 0
       },
-      clientStats: {
-        reads: requestsByMethod.reads,
-        writes: requestsByMethod.writes,
-        successRate: successRateByClient
+      lastWriter: {
+        name: normalizeClientName(stats.lastWriter?.name || 'N/A'),
+        timestamp: stats.lastWriter?.timestamp || 0
+      },
+      lastReader: {
+        name: normalizeClientName(stats.lastReader?.name || 'N/A'),
+        timestamp: stats.lastReader?.timestamp || 0
+      }
+    }
+
+    return NextResponse.json({
+      stats: normalizedStats,
+      timeSeries: {
+        creates: normalizeTimeSeries(timeseries.creates || []),
+        reads: normalizeTimeSeries(timeseries.reads || []),
+        updates: normalizeTimeSeries(timeseries.updates || []),
+        deletes: normalizeTimeSeries(timeseries.deletes || [])
       },
+      // Legacy fields for backward compatibility
       sparklines: {
-        memoryRecords: memoryRecordsSparkline,
-        totalRequests: totalRequestsSparkline,
-        totalClients: totalClientsSparkline,
-        successRate: successRateSparkline
+        memoryRecords: [],
+        totalRequests: [],
+        totalClients: [],
+        successRate: []
+      },
+      clientStats: {
+        reads: {},
+        writes: {},
+        successRate: {}
       }
     })
   } catch (error) {

package/app/api/reset/route.ts

@@ -0,0 +1,83 @@
+import { exec } from 'child_process'
+import { NextRequest, NextResponse } from 'next/server'
+import { promisify } from 'util'
+
+export const dynamic = 'force-dynamic'
+
+const execAsync = promisify(exec)
+
+/**
+ * POST /api/reset
+ * Wipes the OpenMemory database
+ *
+ * Requires confirmation token in body: { confirm: "RESET" }
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json()
+
+    // Require explicit confirmation
+    if (body.confirm !== 'RESET') {
+      return NextResponse.json(
+        { error: 'Confirmation required. Send { confirm: "RESET" }' },
+        { status: 400 }
+      )
+    }
+
+    // Wipe database via docker exec
+    const containerName = process.env.OPENMEMORY_CONTAINER || 'cybermem-openmemory'
+
+    try {
+      // Remove SQLite files
+      await execAsync(
+        `docker exec ${containerName} sh -c 'rm -f /data/openmemory.sqlite*'`
+      )
+
+      // Restart container to reinitialize
+      await execAsync(`docker restart ${containerName}`)
+
+      // Wait for health
+      let healthy = false
+      for (let i = 0; i < 30; i++) {
+        await new Promise(r => setTimeout(r, 2000))
+        try {
+          const healthUrl = process.env.CYBERMEM_URL || 'http://localhost:8626'
+          const res = await fetch(`${healthUrl}/health`, { cache: 'no-store' })
+          if (res.ok) {
+            healthy = true
+            break
+          }
+        } catch {
+          // Still starting up
+        }
+      }
+
+      if (!healthy) {
+        return NextResponse.json(
+          { error: 'Database reset but container failed to become healthy' },
+          { status: 500 }
+        )
+      }
+
+      // Restart log-exporter and db-exporter
+      await execAsync('docker restart cybermem-log-exporter cybermem-db-exporter').catch(() => {})
+
+      return NextResponse.json({
+        success: true,
+        message: 'Database reset successfully'
+      })
+
+    } catch (dockerError: any) {
+      return NextResponse.json(
+        { error: `Docker command failed: ${dockerError.message}` },
+        { status: 500 }
+      )
+    }
+
+  } catch (error: any) {
+    return NextResponse.json(
+      { error: error.message || 'Unknown error' },
+      { status: 500 }
+    )
+  }
+}

package/app/api/restore/route.ts

@@ -0,0 +1,101 @@
+import { exec } from 'child_process'
+import { unlinkSync, writeFileSync } from 'fs'
+import { NextRequest, NextResponse } from 'next/server'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { promisify } from 'util'
+
+export const dynamic = 'force-dynamic'
+
+const execAsync = promisify(exec)
+
+/**
+ * POST /api/restore
+ * Restores the OpenMemory database from uploaded backup
+ *
+ * Accepts multipart/form-data with 'backup' file field
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const formData = await request.formData()
+    const file = formData.get('backup') as File | null
+
+    if (!file) {
+      return NextResponse.json(
+        { error: 'No backup file provided. Upload as "backup" field.' },
+        { status: 400 }
+      )
+    }
+
+    // Validate file type
+    if (!file.name.endsWith('.tar.gz') && !file.name.endsWith('.tgz')) {
+      return NextResponse.json(
+        { error: 'Invalid file type. Must be .tar.gz or .tgz' },
+        { status: 400 }
+      )
+    }
+
+    const containerName = process.env.OPENMEMORY_CONTAINER || 'cybermem-openmemory'
+    const tmpPath = join(tmpdir(), `restore-${Date.now()}.tar.gz`)
+
+    try {
+      // Write uploaded file to temp location
+      const buffer = Buffer.from(await file.arrayBuffer())
+      writeFileSync(tmpPath, buffer)
+
+      // Stop container
+      await execAsync(`docker stop ${containerName}`)
+
+      // Extract backup to container volume
+      await execAsync(
+        `gunzip -c "${tmpPath}" | docker cp - ${containerName}:/`
+      )
+
+      // Clean up temp file
+      unlinkSync(tmpPath)
+
+      // Start container
+      await execAsync(`docker start ${containerName}`)
+
+      // Wait for health
+      let healthy = false
+      for (let i = 0; i < 30; i++) {
+        await new Promise(r => setTimeout(r, 2000))
+        try {
+          const healthUrl = process.env.CYBERMEM_URL || 'http://localhost:8626'
+          const res = await fetch(`${healthUrl}/health`, { cache: 'no-store' })
+          if (res.ok) {
+            healthy = true
+            break
+          }
+        } catch {
+          // Still starting up
+        }
+      }
+
+      // Restart exporters
+      await execAsync('docker restart cybermem-log-exporter cybermem-db-exporter').catch(() => {})
+
+      return NextResponse.json({
+        success: true,
+        message: 'Database restored successfully',
+        healthy
+      })
+
+    } catch (dockerError: any) {
+      // Clean up temp file on error
+      try { unlinkSync(tmpPath) } catch {}
+
+      return NextResponse.json(
+        { error: `Restore failed: ${dockerError.message}` },
+        { status: 500 }
+      )
+    }
+
+  } catch (error: any) {
+    return NextResponse.json(
+      { error: error.message || 'Unknown error' },
+      { status: 500 }
+    )
+  }
+}

package/components/dashboard/audit-log-table.tsx

@@ -47,7 +47,7 @@ export default function AuditLogTable({
   const getClientConfig = (rawName: string) => {
     if (!rawName) return undefined
     const nameLower = rawName.toLowerCase()
-    return clientConfigs.find((c: any) => nameLower.includes(c.match))
+    return clientConfigs.find((c: any) => new RegExp(c.match, 'i').test(nameLower))
   }
 
   const getClientDisplayName = (rawName: string) => {

package/components/dashboard/metrics-chart.tsx

@@ -86,9 +86,9 @@ export default function MetricsChart({
             )}
             {isMultiSeries ? (
                 clientNames.map((client, i) => {
-                    // Find matching config
+                    // Find matching config using regex
                     const keyLower = client.toLowerCase()
-                    const config = clientConfigs.find((c: any) => keyLower.includes(c.match))
+                    const config = clientConfigs.find((c: any) => new RegExp(c.match, 'i').test(keyLower))
 
                     // Use config if found, otherwise fallback
                     const name = config?.name || client

package/components/dashboard/metrics-grid.tsx

@@ -1,7 +1,6 @@
 "use client"
 
 import { Card, CardContent } from "@/components/ui/card"
-import { useDashboard } from "@/lib/data/dashboard-context"
 import MetricCard from "./metric-card"
 
 // Types
@@ -32,16 +31,7 @@ interface MetricsGridProps {
 
 
 export default function MetricsGrid({ stats, trends }: MetricsGridProps) {
-  const { clientConfigs } = useDashboard()
-
-  const getClientDisplayName = (rawName: string) => {
-    if (!rawName || rawName === "N/A" || rawName === "unknown") return rawName
-
-    const nameLower = rawName.toLowerCase()
-    // Find matching client config (e.g. "antigravity" matches "antigravity-client")
-    const config = clientConfigs.find((c: any) => nameLower.includes(c.match))
-    return config ? config.name : rawName
-  }
+  // Note: Client names are now normalized by backend API, no frontend transformation needed
 
   const formatTimestamp = (timestamp: number) => {
     if (timestamp <= 0) return "No activity"
@@ -99,7 +89,7 @@ export default function MetricsGrid({ stats, trends }: MetricsGridProps) {
       <Card className="bg-white/5 border-white/10 backdrop-blur-md text-white shadow-lg overflow-hidden">
         <CardContent className="pt-6 pb-6 relative">
           <div className="text-sm font-medium text-slate-400 mb-2">Top Writer</div>
-          <div className="text-4xl font-bold text-white mb-1 truncate">{getClientDisplayName(stats.topWriter.name)}</div>
+          <div className="text-4xl font-bold text-white mb-1 truncate">{stats.topWriter.name}</div>
           <div className="text-xl text-white/80 whitespace-nowrap">
             {stats.topWriter.count > 0 ? `${stats.topWriter.count.toLocaleString()} writes` : ""}
           </div>
@@ -111,7 +101,7 @@ export default function MetricsGrid({ stats, trends }: MetricsGridProps) {
         <CardContent className="pt-6 pb-6 relative">
           <div className="text-sm font-medium text-slate-400 mb-2">Top Reader</div>
           <div className="text-4xl font-bold text-white mb-1 truncate">
-            {stats.topReader.count > 0 ? getClientDisplayName(stats.topReader.name) : "N/A"}
+            {stats.topReader.count > 0 ? stats.topReader.name : "N/A"}
           </div>
           <div className="text-xl text-white/80 whitespace-nowrap">
             {stats.topReader.count > 0 ? `${stats.topReader.count.toLocaleString()} reads` : ""}
@@ -124,7 +114,7 @@ export default function MetricsGrid({ stats, trends }: MetricsGridProps) {
         <CardContent className="pt-6 pb-6 relative">
           <div className="text-sm font-medium text-slate-400 mb-2">Last Writer</div>
           <div className="text-4xl font-bold text-white mb-1 truncate">
-            {stats.lastWriter.name !== "N/A" ? getClientDisplayName(stats.lastWriter.name) : "N/A"}
+            {stats.lastWriter.name !== "N/A" ? stats.lastWriter.name : "N/A"}
           </div>
           <div className="text-xl text-white/80 whitespace-nowrap">
             {stats.lastWriter.timestamp > 0 ? formatTimestamp(stats.lastWriter.timestamp) : "No activity"}
@@ -137,7 +127,7 @@ export default function MetricsGrid({ stats, trends }: MetricsGridProps) {
         <CardContent className="pt-6 pb-6 relative">
           <div className="text-sm font-medium text-slate-400 mb-2">Last Reader</div>
           <div className="text-4xl font-bold text-white mb-1 truncate">
-            {stats.lastReader.name !== "N/A" ? getClientDisplayName(stats.lastReader.name) : "N/A"}
+            {stats.lastReader.name !== "N/A" ? stats.lastReader.name : "N/A"}
           </div>
           <div className="text-xl text-white/80 whitespace-nowrap">
             {stats.lastReader.timestamp > 0 ? formatTimestamp(stats.lastReader.timestamp) : "No activity"}

package/e2e/infra-check.spec.ts

@@ -0,0 +1,97 @@
+/**
+ * Infrastructure Pre-flight Checks
+ *
+ * Run BEFORE any happy path tests to validate:
+ * - Dashboard API responds
+ * - db-exporter /api/stats works
+ * - Client name normalization works
+ *
+ * Usage: npm run test:e2e -- infra-check.spec.ts
+ */
+
+import { expect, test } from '@playwright/test';
+
+const DASHBOARD_URL = process.env.BASE_URL || 'http://localhost:3000';
+const DB_EXPORTER_URL = process.env.DB_EXPORTER_URL || 'http://localhost:8000';
+const MCP_URL = process.env.MCP_URL || 'http://localhost:8626';
+
+test.describe('Infrastructure Pre-flight Checks', () => {
+
+    test('1. MCP Health endpoint responds', async ({ request }) => {
+        const res = await request.get(`${MCP_URL}/health`);
+        expect(res.ok()).toBeTruthy();
+        const data = await res.json();
+        expect(data.ok).toBe(true);
+        console.log('✅ MCP Health: OK');
+    });
+
+    test('2. db-exporter /api/stats responds', async ({ request }) => {
+        const res = await request.get(`${DB_EXPORTER_URL}/api/stats`);
+        expect(res.ok()).toBeTruthy();
+        const data = await res.json();
+        expect(typeof data.memoryRecords).toBe('number');
+        expect(typeof data.totalClients).toBe('number');
+        expect(typeof data.successRate).toBe('number');
+        console.log(`✅ db-exporter: ${data.memoryRecords} memories, ${data.totalClients} clients`);
+    });
+
+    test('3. db-exporter /api/timeseries responds', async ({ request }) => {
+        const res = await request.get(`${DB_EXPORTER_URL}/api/timeseries?period=24h`);
+        expect(res.ok()).toBeTruthy();
+        const data = await res.json();
+        expect(Array.isArray(data.creates)).toBeTruthy();
+        expect(Array.isArray(data.reads)).toBeTruthy();
+        console.log('✅ db-exporter timeseries: OK');
+    });
+
+    test('4. Dashboard /api/metrics responds', async ({ request }) => {
+        const res = await request.get(`${DASHBOARD_URL}/api/metrics`);
+        expect(res.ok()).toBeTruthy();
+        const data = await res.json();
+        expect(data.stats).toBeDefined();
+        expect(typeof data.stats.memoryRecords).toBe('number');
+        console.log(`✅ Dashboard API: ${data.stats.memoryRecords} memories`);
+    });
+
+    test('5. Dashboard /api/audit-logs responds', async ({ request }) => {
+        const res = await request.get(`${DASHBOARD_URL}/api/audit-logs`);
+        expect(res.ok()).toBeTruthy();
+        const data = await res.json();
+        expect(Array.isArray(data.logs)).toBeTruthy();
+        console.log(`✅ Audit Logs API: ${data.logs.length} entries`);
+    });
+
+    test('6. Client name normalization works', async ({ request }) => {
+        // Check that clients.json is accessible
+        const configRes = await request.get(`${DASHBOARD_URL}/clients.json`);
+        expect(configRes.ok()).toBeTruthy();
+        const config = await configRes.json();
+
+        // Verify Antigravity mapping exists
+        const antigravity = config.find((c: any) => c.name === 'Antigravity');
+        expect(antigravity).toBeDefined();
+        expect(antigravity.match).toContain('antigravity');
+        console.log(`✅ Client normalization: Antigravity pattern = "${antigravity.match}"`);
+    });
+
+    test('7. Dashboard UI loads', async ({ page }) => {
+        await page.goto(DASHBOARD_URL);
+
+        // Handle login if needed
+        const passwordInput = page.getByPlaceholder('Enter admin password');
+        if (await passwordInput.isVisible({ timeout: 2000 }).catch(() => false)) {
+            await passwordInput.fill('admin');
+            await page.keyboard.press('Enter');
+        }
+
+        // Dismiss password warning if present
+        const dontShowBtn = page.locator('button:has-text("Don\'t show again")');
+        if (await dontShowBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
+            await dontShowBtn.click();
+        }
+
+        // Verify dashboard loaded
+        await expect(page.getByRole('heading', { name: 'CyberMem' })).toBeVisible({ timeout: 15000 });
+        console.log('✅ Dashboard UI: Loaded');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cybermem/dashboard",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "CyberMem Monitoring Dashboard",
   "homepage": "https://cybermem.dev",
   "repository": {

package/public/clients.json

@@ -35,7 +35,7 @@
   {
     "id": "antigravity",
     "name": "Antigravity",
-    "match": "antigravity",
+    "match": "antigravity|antigravity-client",
     "color": "#d946ef",
     "icon": "/icons/antigravity.png",
     "description": "Antigravity supports MCP via raw JSON configuration.",