@cybermem/dashboard 0.5.14 → 0.8.5

package/app/api/metrics/route.ts

@@ -1,125 +1,311 @@
-import fs from 'fs'
-import { NextResponse } from 'next/server'
-import path from 'path'
+import fs from "fs";
+import { NextResponse } from "next/server";
+import path from "path";
 
-export const dynamic = 'force-dynamic'
-export const revalidate = 0
+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'
+const DB_EXPORTER_URL = process.env.DB_EXPORTER_URL || "http://localhost:8000";
+const PROMETHEUS_URL = process.env.PROMETHEUS_URL || "http://localhost:9092";
 
 // Load clients config for name normalization
-let clientsConfig: any[] = []
+let clientsConfig: any[] = [];
 try {
-  const configPath = path.join(process.cwd(), 'public', 'clients.json')
-  clientsConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+  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)
+  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()
+  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)
+      return new RegExp(c.match, "i").test(nameLower);
     } catch {
-      return nameLower.includes(c.match)
+      return nameLower.includes(c.match);
     }
-  })
-  return client?.name || rawName
+  });
+  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 }
+  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
+      if (key !== "time") {
+        const normalizedKey = normalizeClientName(key);
+        normalized[normalizedKey] = value;
       }
     }
-    return normalized
-  })
+    return normalized;
+  });
 }
 
 export async function GET(request: Request) {
   try {
-    const { searchParams } = new URL(request.url)
-    const period = searchParams.get('period') || '24h'
-
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), 5000)
-
-    // 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'
-      })
-    ])
-
-    clearTimeout(timeoutId)
-
-    if (!statsRes.ok) {
-      throw new Error(`Failed to fetch stats: ${statsRes.statusText}`)
-    }
+    const { searchParams } = new URL(request.url);
+    const period = searchParams.get("period") || "24h";
 
-    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
-      },
-      topReader: {
-        name: normalizeClientName(stats.topReader?.name || 'N/A'),
-        count: stats.topReader?.count || 0
-      },
-      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
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
+
+    // --- PRIMARY DATA SOURCE: DIRECT SQLITE ---
+    let stats = {
+      memoryRecords: 0,
+      totalClients: 0,
+      successRate: 100,
+      totalRequests: 0,
+      topWriter: { name: "N/A", count: 0 },
+      topReader: { name: "N/A", count: 0 },
+      lastWriter: { name: "N/A", timestamp: 0 },
+      lastReader: { name: "N/A", timestamp: 0 },
+    };
+    let timeseries: Record<string, any[]> = {
+      creates: [],
+      reads: [],
+      updates: [],
+      deletes: [],
+    };
+
+    const homedir = process.env.HOME || process.env.USERPROFILE || "";
+    const dbPath =
+      process.env.OM_DB_PATH ||
+      path.resolve(homedir, ".cybermem/data/openmemory.sqlite");
+
+    if (fs.existsSync(dbPath)) {
+      console.error(`[STATS-API] Reading SQLite from ${dbPath}`);
+      try {
+        const sqlite3 = require("sqlite3").verbose();
+        const { open } = require("sqlite");
+        const db = await open({
+          filename: dbPath,
+          driver: sqlite3.Database,
+        });
+
+        // Basic Stats
+        const memories = await db.get("SELECT COUNT(*) as count FROM memories");
+        const totalReqs = await db.get(
+          "SELECT COUNT(*) as count FROM cybermem_access_log",
+        );
+        const errReqs = await db.get(
+          "SELECT COUNT(*) as count FROM cybermem_access_log WHERE is_error = 1",
+        );
+        const lastWrite = await db.get(
+          "SELECT client_name, timestamp FROM cybermem_access_log WHERE operation = 'create' ORDER BY timestamp DESC LIMIT 1",
+        );
+        const lastRead = await db.get(
+          "SELECT client_name, timestamp FROM cybermem_access_log WHERE operation = 'read' ORDER BY timestamp DESC LIMIT 1",
+        );
+        const uniqueClients = await db.get(
+          "SELECT COUNT(DISTINCT client_name) as count FROM cybermem_access_log",
+        );
+
+        stats.memoryRecords = memories?.count || 0;
+        stats.totalRequests = totalReqs?.count || 0;
+        stats.totalClients = uniqueClients?.count || 0;
+        stats.successRate =
+          stats.totalRequests > 0
+            ? ((stats.totalRequests - (errReqs?.count || 0)) /
+                stats.totalRequests) *
+              100
+            : 100;
+
+        console.error(
+          `[STATS-API] SQLite stats: ${stats.totalRequests} total requests, ${stats.memoryRecords} records`,
+        );
+
+        if (lastWrite) {
+          stats.lastWriter = {
+            name: normalizeClientName(lastWrite.client_name),
+            timestamp: lastWrite.timestamp,
+          };
+          console.error(`[STATS-API] Last writer: ${stats.lastWriter.name}`);
+        }
+        if (lastRead) {
+          stats.lastReader = {
+            name: normalizeClientName(lastRead.client_name),
+            timestamp: lastRead.timestamp,
+          };
+          console.error(`[STATS-API] Last reader: ${stats.lastReader.name}`);
+        }
+
+        // Top activity
+        const topWriter = await db.get(
+          "SELECT client_name, COUNT(*) as count FROM cybermem_access_log WHERE operation = 'create' GROUP BY client_name ORDER BY count DESC LIMIT 1",
+        );
+        const topReader = await db.get(
+          "SELECT client_name, COUNT(*) as count FROM cybermem_access_log WHERE operation = 'read' GROUP BY client_name ORDER BY count DESC LIMIT 1",
+        );
+
+        if (topWriter)
+          stats.topWriter = {
+            name: normalizeClientName(topWriter.client_name),
+            count: topWriter.count,
+          };
+        if (topReader)
+          stats.topReader = {
+            name: normalizeClientName(topReader.client_name),
+            count: topReader.count,
+          };
+
+        // --- TIME SERIES AGGREGATION (Robust Linear Sampling) ---
+        let periodMs = 24 * 60 * 60 * 1000; // Default 24h
+        if (period === "1h") periodMs = 60 * 60 * 1000;
+        else if (period === "7d") periodMs = 7 * 24 * 60 * 60 * 1000;
+        else if (period === "30d") periodMs = 30 * 24 * 60 * 60 * 1000;
+        else if (period === "90d") periodMs = 90 * 24 * 60 * 60 * 1000;
+        else if (period === "24h") periodMs = 24 * 60 * 60 * 1000;
+
+        const now = Date.now();
+        const startTime = now - periodMs;
+
+        console.error(
+          `[STATS-API] Fetching cumulative chart data since ${new Date(startTime).toISOString()}`,
+        );
+
+        // Get all logs in period
+        const allLogs = await db.all(
+          `
+          SELECT timestamp, operation, client_name
+          FROM cybermem_access_log
+          WHERE timestamp > ?
+          ORDER BY timestamp ASC
+        `,
+          [startTime],
+        );
+
+        // Get base counts (before startTime) to start the cumulative graph correctly
+        const baseCounts = await db.all(
+          `
+          SELECT operation, client_name, COUNT(*) as count
+          FROM cybermem_access_log
+          WHERE timestamp <= ?
+          GROUP BY 1, 2
+        `,
+          [startTime],
+        );
+
+        const buildBeautifulSeries = (targetOp: string) => {
+          const clientTotals: Record<string, number> = {};
+
+          // 1. Initialize with base counts
+          baseCounts
+            .filter((b: any) => b.operation === targetOp)
+            .forEach((b: any) => {
+              clientTotals[b.client_name] = b.count;
+            });
+
+          const series: any[] = [];
+          const opLogs = allLogs.filter((l: any) => l.operation === targetOp);
+
+          // 2. Linear Sampling (60 points)
+          const SAMPLES = 60;
+          const interval = (now - startTime) / SAMPLES;
+          let currentLogIdx = 0;
+
+          for (let i = 0; i <= SAMPLES; i++) {
+            const timePoint = startTime + i * interval;
+
+            // Catch up logs that happened before this timePoint
+            while (
+              currentLogIdx < opLogs.length &&
+              opLogs[currentLogIdx].timestamp <= timePoint
+            ) {
+              const log = opLogs[currentLogIdx];
+              clientTotals[log.client_name] =
+                (clientTotals[log.client_name] || 0) + 1;
+              currentLogIdx++;
+            }
+
+            // Record state at this exact linear time point
+            series.push({
+              time: Math.floor(timePoint / 1000),
+              ...clientTotals,
+            });
+          }
+
+          return series;
+        };
+
+        timeseries.creates = buildBeautifulSeries("create");
+        timeseries.reads = buildBeautifulSeries("read");
+        timeseries.updates = buildBeautifulSeries("update");
+        timeseries.deletes = buildBeautifulSeries("delete");
+
+        console.error(`[STATS-API] SQLite Stats & Beautiful Charts processed.`);
+
+        await db.close();
+      } catch (dbErr) {
+        console.error(
+          "[STATS-API] Direct SQLite metrics fetch failed, trying db-exporter fallback:",
+          dbErr,
+        );
+        try {
+          const exporterRes = await fetch(`${DB_EXPORTER_URL}/metrics`, {
+            signal: controller.signal,
+          });
+          if (exporterRes.ok) {
+            const text = await exporterRes.text();
+            const getValue = (name: string) => {
+              const match = text.match(new RegExp(`${name}\\s+([\\d.]+)`));
+              return match ? parseFloat(match[1]) : 0;
+            };
+            stats.memoryRecords = getValue("openmemory_memories_total");
+            stats.totalRequests = getValue(
+              "openmemory_requests_aggregate_total",
+            );
+            stats.successRate = getValue("openmemory_success_rate_aggregate");
+            console.error(
+              `[STATS-API] Fallback stats from db-exporter: ${stats.totalRequests} total requests`,
+            );
+          }
+        } catch (exporterErr) {
+          console.error("[STATS-API] Fallback fetch failed:", exporterErr);
+        }
       }
+    } else {
+      console.error(`[STATS-API] SQLite DB NOT FOUND at ${dbPath}`);
     }
 
+    clearTimeout(timeoutId);
+
     return NextResponse.json({
-      stats: normalizedStats,
+      stats: {
+        ...stats,
+        topWriter: {
+          name: normalizeClientName(stats.topWriter?.name || "N/A"),
+          count: stats.topWriter?.count || 0,
+        },
+        topReader: {
+          name: normalizeClientName(stats.topReader?.name || "N/A"),
+          count: stats.topReader?.count || 0,
+        },
+        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,
+        },
+      },
       timeSeries: {
         creates: normalizeTimeSeries(timeseries.creates || []),
         reads: normalizeTimeSeries(timeseries.reads || []),
         updates: normalizeTimeSeries(timeseries.updates || []),
-        deletes: normalizeTimeSeries(timeseries.deletes || [])
+        deletes: normalizeTimeSeries(timeseries.deletes || []),
       },
-      // Legacy fields for backward compatibility
-      sparklines: {
-        memoryRecords: [],
-        totalRequests: [],
-        totalClients: [],
-        successRate: []
-      },
-      clientStats: {
-        reads: {},
-        writes: {},
-        successRate: {}
-      }
-    })
+    });
   } catch (error) {
-    console.error('Failed to fetch metrics:', error)
-    return NextResponse.json({ error: 'Failed to fetch metrics' }, { status: 500 })
+    console.error("Failed to fetch metrics:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch metrics" },
+      { status: 500 },
+    );
   }
 }

package/app/api/reset/route.ts

@@ -50,7 +50,7 @@ export async function POST(request: NextRequest) {
         message: `Deleted ${deletedCount} database files. Restart openmemory container to reinitialize.`,
         deletedCount,
         restartRequired: true,
-        restartCommand: 'docker restart cybermem-openmemory'
+        restartCommand: 'docker restart cybermem-mcp'
       })
 
     } catch (fsError: any) {

package/app/api/restore/route.ts

@@ -59,7 +59,7 @@ export async function POST(request: NextRequest) {
         success: true,
         message: 'Database restored successfully. Restart openmemory container to apply.',
         restartRequired: true,
-        restartCommand: 'docker restart cybermem-openmemory'
+        restartCommand: 'docker restart cybermem-mcp'
       })
 
     } catch (restoreError: any) {

package/app/api/settings/route.ts

@@ -1,10 +1,10 @@
-import { checkRateLimit, rateLimitResponse } from '@/lib/rate-limit'
-import fs from 'fs'
-import { NextRequest, NextResponse } from 'next/server'
+import { checkRateLimit, rateLimitResponse } from "@/lib/rate-limit";
+import fs from "fs";
+import { NextRequest, NextResponse } from "next/server";
 
-export const dynamic = 'force-dynamic'
+export const dynamic = "force-dynamic";
 
-const CONFIG_PATH = '/data/config.json'
+const CONFIG_PATH = "/data/config.json";
 
 export async function GET(request: NextRequest) {
   // Rate limiting check
@@ -13,39 +13,50 @@ export async function GET(request: NextRequest) {
     return rateLimitResponse(rateLimit.resetIn);
   }
 
-  let apiKey = process.env.OM_API_KEY || 'not-set'
+  let apiKey = process.env.OM_API_KEY || "not-set";
 
   // Try to read from HttpOnly cookie first
-  const cookieKey = request.cookies.get('cybermem_api_key')?.value
+  const cookieKey = request.cookies.get("cybermem_api_key")?.value;
   if (cookieKey) {
-    apiKey = cookieKey
+    apiKey = cookieKey;
   }
 
   // Fallback to config file
   try {
-     if (fs.existsSync(CONFIG_PATH)) {
-        const raw = fs.readFileSync(CONFIG_PATH, 'utf-8')
-        const conf = JSON.parse(raw)
-        if (conf.api_key && apiKey === 'not-set') apiKey = conf.api_key
-     }
+    if (fs.existsSync(CONFIG_PATH)) {
+      const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+      const conf = JSON.parse(raw);
+      if (conf.api_key && apiKey === "not-set") apiKey = conf.api_key;
+    }
   } catch (e) {
-      // ignore
+    // ignore
   }
 
   // Endpoint resolution:
   // 1. Env var CYBERMEM_URL
   // 2. Default to localhost:8088/memory (Managed Mode)
   const rawEndpoint = process.env.CYBERMEM_URL;
-  const endpoint = rawEndpoint || 'http://localhost:8088/memory';
-  const isManaged = !rawEndpoint;
-
-  return NextResponse.json({
-    apiKey: apiKey,
-    endpoint,
-    isManaged
-  }, {
-    headers: {
-      'X-RateLimit-Remaining': String(rateLimit.remaining)
-    }
-  })
+  const endpoint = rawEndpoint || "http://localhost:8626/memory";
+  // isManaged = Local Mode (No Auth). Only if NO URL and NO API KEY.
+  // If API Key is present (RPi), we are in "Secure/Legacy" mode, not Local.
+  // In local development, rawEndpoint might be unset, but we still want to not be "managed" if we want to test auth flows.
+  const isManaged =
+    !rawEndpoint &&
+    (!process.env.OM_API_KEY || process.env.OM_API_KEY === "dev-secret-key");
+
+  return NextResponse.json(
+    {
+      token: apiKey,
+      apiKey: apiKey,
+      endpoint,
+      isManaged,
+      dashboardVersion: "v0.7.5",
+      mcpVersion: "v0.7.5",
+    },
+    {
+      headers: {
+        "X-RateLimit-Remaining": String(rateLimit.remaining),
+      },
+    },
+  );
 }

package/app/api/system/restart/route.ts

@@ -6,7 +6,7 @@ export const dynamic = 'force-dynamic'
 export async function POST(req: Request) {
   try {
     const docker = new Docker({ socketPath: '/var/run/docker.sock' });
-    const container = docker.getContainer('cybermem-openmemory');
+    const container = docker.getContainer('cybermem-mcp');
 
     await container.restart();
 

package/app/layout.tsx

@@ -1,37 +1,45 @@
-import { DashboardProvider } from "@/lib/data/dashboard-context"
-import { Analytics } from "@vercel/analytics/next"
-import type { Metadata } from "next"
-import { Exo_2, Geist, Geist_Mono } from "next/font/google"
-import type React from "react"
-import "./globals.css"
+import { DashboardProvider } from "@/lib/data/dashboard-context";
+import { Analytics } from "@vercel/analytics/next";
+import type { Metadata } from "next";
+import { Exo_2, Geist, Geist_Mono } from "next/font/google";
+import type React from "react";
+import "./globals.css";
 
-const _geist = Geist({ subsets: ["latin"] })
-const _geistMono = Geist_Mono({ subsets: ["latin"] })
-const exo2 = Exo_2({ subsets: ["latin"], variable: "--font-exo2" })
+const _geist = Geist({ subsets: ["latin"] });
+const _geistMono = Geist_Mono({ subsets: ["latin"] });
+const exo2 = Exo_2({ subsets: ["latin"], variable: "--font-exo2" });
 
 export const metadata: Metadata = {
   title: "CyberMem",
   description: "Real-time memory operations dashboard",
   icons: {
-    icon: '/favicon-dark.svg',
-    shortcut: '/favicon-dark.svg',
-    apple: '/favicon-dark.svg',
+    icon: "/favicon-dark.svg",
+    shortcut: "/favicon-dark.svg",
+    apple: "/favicon-dark.svg",
   },
-}
+};
+
+import { headers } from "next/headers";
 
-export default function RootLayout({
+// ... imports ...
+
+export default async function RootLayout({
   children,
 }: Readonly<{
-  children: React.ReactNode
+  children: React.ReactNode;
 }>) {
+  const headersList = await headers();
+  const userId = headersList.get("x-user-id");
+  const initialAuth = !!userId;
+
   return (
     <html lang="en" suppressHydrationWarning className="relative">
       <body className={`font-sans antialiased relative z-10 ${exo2.variable}`}>
-        <DashboardProvider>
+        <DashboardProvider initialAuth={initialAuth}>
           {children}
         </DashboardProvider>
         <Analytics />
       </body>
     </html>
-  )
+  );
 }