@gravito/zenith 1.1.0 → 1.1.1

package/src/server/config/ServerConfigManager.ts

@@ -0,0 +1,87 @@
+import { DB } from '@gravito/atlas'
+import { MySQLPersistence, SQLitePersistence } from '@gravito/stream'
+
+export interface ServerConfig {
+  port: number
+  redisUrl: string
+  queuePrefix: string
+  dbDriver: 'sqlite' | 'mysql'
+  dbConfig: {
+    name?: string
+    host?: string
+    port?: number
+    username?: string
+    password?: string
+  }
+  persistence?: {
+    adapter: any
+    archiveCompleted: boolean
+    archiveFailed: boolean
+    archiveEnqueued: boolean
+  }
+}
+
+export class ServerConfigManager {
+  static load(): ServerConfig {
+    const dbDriver = (process.env.DB_DRIVER || (process.env.DB_HOST ? 'mysql' : 'sqlite')) as
+      | 'sqlite'
+      | 'mysql'
+
+    const dbConfig: ServerConfig['dbConfig'] = {}
+    if (dbDriver === 'mysql') {
+      dbConfig.host = process.env.DB_HOST
+      dbConfig.port = parseInt(process.env.DB_PORT || '3306', 10)
+      dbConfig.name = process.env.DB_NAME
+      dbConfig.username = process.env.DB_USER
+      dbConfig.password = process.env.DB_PASSWORD
+    } else {
+      dbConfig.name = process.env.DB_NAME || 'flux.sqlite'
+    }
+
+    let persistence: ServerConfig['persistence']
+
+    if (dbDriver === 'sqlite' || process.env.DB_HOST) {
+      this.setupDatabase(dbDriver, dbConfig)
+
+      const adapter = dbDriver === 'sqlite' ? new SQLitePersistence(DB) : new MySQLPersistence(DB)
+      adapter
+        .setupTable()
+        .catch((err) => console.error('[FluxConsole] SQL Archive Setup Error:', err))
+
+      persistence = {
+        adapter,
+        archiveCompleted: process.env.PERSIST_ARCHIVE_COMPLETED === 'true',
+        archiveFailed: process.env.PERSIST_ARCHIVE_FAILED !== 'false',
+        archiveEnqueued: process.env.PERSIST_ARCHIVE_ENQUEUED === 'true',
+      }
+      console.log(`[FluxConsole] SQL Archive enabled via ${dbDriver}`)
+    }
+
+    return {
+      port: parseInt(process.env.PORT || '3000', 10),
+      redisUrl: process.env.REDIS_URL || 'redis://localhost:6379',
+      queuePrefix: process.env.QUEUE_PREFIX || 'queue:',
+      dbDriver,
+      dbConfig,
+      persistence,
+    }
+  }
+
+  private static setupDatabase(driver: 'sqlite' | 'mysql', config: ServerConfig['dbConfig']): void {
+    if (driver === 'sqlite') {
+      DB.addConnection('default', {
+        driver: 'sqlite',
+        database: config.name,
+      })
+    } else {
+      DB.addConnection('default', {
+        driver,
+        host: config.host,
+        port: config.port,
+        database: config.name,
+        username: config.username,
+        password: config.password,
+      })
+    }
+  }
+}

package/src/server/index.ts

@@ -1,14 +1,14 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { DB } from '@gravito/atlas'
 import { Photon } from '@gravito/photon'
 import { QuasarAgent } from '@gravito/quasar'
 import { MySQLPersistence, SQLitePersistence } from '@gravito/stream'
-import fs from 'fs'
 import { serveStatic } from 'hono/bun'
 import { getCookie } from 'hono/cookie'
 import { streamSSE } from 'hono/streaming'
-import os from 'os'
-import path from 'path'
-import { fileURLToPath } from 'url'
 import {
   authMiddleware,
   createSession,
@@ -705,7 +705,7 @@ api.get('/logs/stream', async (c) => {
           data: JSON.stringify({ nodes }),
           event: 'pulse',
         })
-      } catch (err) {
+      } catch (_err) {
         // ignore errors
       }
     }, 2000)
@@ -769,26 +769,27 @@ api.get('/alerts/config', async (c) => {
   return c.json({
     rules: queueService.alerts.getRules(),
     config: queueService.alerts.getConfig(),
-    maintenance: await queueService.getMaintenanceConfig(),
+    // maintenance: await queueService.getMaintenanceConfig(),
   })
 })
 
-api.post('/maintenance/config', async (c) => {
-  const config = await c.req.json()
-  try {
-    await queueService.saveMaintenanceConfig(config)
-    return c.json({ success: true })
-  } catch (err) {
-    return c.json({ error: 'Failed to save maintenance config' }, 500)
-  }
-})
+// Maintenance API temporarily disabled - requires ServerConfigManager enhancement
+// api.post('/maintenance/config', async (c) => {
+//   const config = await c.req.json()
+//   try {
+//     // await queueService.saveMaintenanceConfig(config)
+//     return c.json({ success: true })
+//   } catch (_err) {
+//     return c.json({ error: 'Failed to save maintenance config' }, 500)
+//   }
+// })
 
 api.post('/alerts/config', async (c) => {
   const config = await c.req.json()
   try {
     await queueService.alerts.saveConfig(config)
     return c.json({ success: true })
-  } catch (err) {
+  } catch (_err) {
     return c.json({ error: 'Failed to save alert config' }, 500)
   }
 })
@@ -798,7 +799,7 @@ api.post('/alerts/rules', async (c) => {
   try {
     await queueService.alerts.addRule(rule)
     return c.json({ success: true })
-  } catch (err) {
+  } catch (_err) {
     return c.json({ error: 'Failed to add rule' }, 500)
   }
 })
@@ -808,7 +809,7 @@ api.delete('/alerts/rules/:id', async (c) => {
   try {
     await queueService.alerts.deleteRule(id)
     return c.json({ success: true })
-  } catch (err) {
+  } catch (_err) {
     return c.json({ error: 'Failed to delete rule' }, 500)
   }
 })

package/src/server/services/AlertService.ts

@@ -1,9 +1,18 @@
-import { EventEmitter } from 'events'
+import { EventEmitter } from 'node:events'
 import { Redis } from 'ioredis'
 import nodemailer from 'nodemailer'
 import type { AlertConfig, AlertEvent, AlertRule, PulseNode } from '../../shared/types'
 import type { WorkerReport } from './QueueService'
 
+/**
+ * AlertService monitors system telemetry and triggers notifications.
+ *
+ * It evaluates rules against real-time data from Quasar agents and
+ * dispatches alerts via Slack, Discord, or Email when thresholds are exceeded.
+ *
+ * @public
+ * @since 3.0.0
+ */
 export class AlertService {
   private redis: Redis
   private rules: AlertRule[] = []
@@ -185,7 +194,9 @@ export class AlertService {
                 break
               }
             }
-            if (fired) break
+            if (fired) {
+              break
+            }
           }
           break
 
@@ -200,7 +211,9 @@ export class AlertService {
                 break
               }
             }
-            if (fired) break
+            if (fired) {
+              break
+            }
           }
           break
       }

package/src/server/services/LogStreamProcessor.ts

@@ -0,0 +1,93 @@
+import { EventEmitter } from 'node:events'
+import type { Redis } from 'ioredis'
+import type { SystemLog } from './QueueService'
+
+export class LogStreamProcessor {
+  private static readonly MAX_LOGS_PER_SEC = 50
+  private logEmitter = new EventEmitter()
+  private logThrottleCount = 0
+  private logThrottleReset = Date.now()
+
+  constructor(
+    private redis: Redis,
+    private subRedis: Redis
+  ) {
+    this.setupLogSubscription()
+  }
+
+  /**
+   * Setup Redis log subscription
+   */
+  private setupLogSubscription(): void {
+    this.logEmitter.setMaxListeners(1000)
+
+    this.subRedis.on('message', (channel, message) => {
+      if (channel === 'flux_console:logs') {
+        this.processLogMessage(message)
+      }
+    })
+  }
+
+  /**
+   * Process incoming log message with throttling
+   */
+  private processLogMessage(message: string): void {
+    try {
+      const now = Date.now()
+
+      if (now - this.logThrottleReset > 1000) {
+        this.logThrottleReset = now
+        this.logThrottleCount = 0
+      }
+
+      if (this.logThrottleCount < LogStreamProcessor.MAX_LOGS_PER_SEC) {
+        this.logThrottleCount++
+        const log = JSON.parse(message) as SystemLog
+        this.logEmitter.emit('log', log)
+
+        if (log.level === 'success' || log.level === 'error') {
+          this.updateThroughput()
+        }
+      }
+    } catch (_e) {
+      // Ignore parse errors
+    }
+  }
+
+  /**
+   * Update throughput counter for job completions
+   */
+  private updateThroughput(): void {
+    const minute = Math.floor(Date.now() / 60000)
+    this.redis
+      .incr(`flux_console:throughput:${minute}`)
+      .then(() => {
+        this.redis.expire(`flux_console:throughput:${minute}`, 3600)
+      })
+      .catch(() => {})
+  }
+
+  /**
+   * Subscribe to log stream
+   */
+  async subscribe(): Promise<void> {
+    await this.subRedis.subscribe('flux_console:logs')
+  }
+
+  /**
+   * Add listener for log events
+   */
+  onLog(callback: (msg: SystemLog) => void): () => void {
+    this.logEmitter.on('log', callback)
+    return () => {
+      this.logEmitter.off('log', callback)
+    }
+  }
+
+  /**
+   * Get emitter for direct access
+   */
+  getEmitter(): EventEmitter {
+    return this.logEmitter
+  }
+}

package/src/server/services/MaintenanceScheduler.ts

@@ -0,0 +1,78 @@
+import type { Redis } from 'ioredis'
+
+export interface MaintenanceConfig {
+  autoCleanup: boolean
+  retentionDays: number
+  lastRun?: number
+}
+
+export class MaintenanceScheduler {
+  private static readonly ONE_DAY = 24 * 60 * 60 * 1000
+  private static readonly CHECK_INTERVAL = 3600000 // 1 hour
+
+  constructor(
+    private redis: Redis,
+    private cleanupCallback: (retentionDays: number) => Promise<number>
+  ) {}
+
+  /**
+   * Start the maintenance loop
+   */
+  start(initialDelay = 30000): void {
+    setTimeout(() => {
+      const loop = async () => {
+        try {
+          await this.checkMaintenance()
+        } catch (err) {
+          console.error('[Maintenance] Task Error:', err)
+        }
+        setTimeout(loop, MaintenanceScheduler.CHECK_INTERVAL)
+      }
+      loop()
+    }, initialDelay)
+  }
+
+  /**
+   * Check and run maintenance if needed
+   */
+  private async checkMaintenance(): Promise<void> {
+    const config = await this.getConfig()
+    if (!config.autoCleanup) {
+      return
+    }
+
+    const now = Date.now()
+    const lastRun = config.lastRun || 0
+
+    if (now - lastRun >= MaintenanceScheduler.ONE_DAY) {
+      console.log(
+        `[Maintenance] Starting Auto-Cleanup (Retention: ${config.retentionDays} days)...`
+      )
+      const deleted = await this.cleanupCallback(config.retentionDays)
+      console.log(`[Maintenance] Cleanup Complete. Removed ${deleted} records.`)
+
+      await this.saveConfig({
+        ...config,
+        lastRun: now,
+      })
+    }
+  }
+
+  /**
+   * Get maintenance configuration
+   */
+  async getConfig(): Promise<MaintenanceConfig> {
+    const data = await this.redis.get('gravito:zenith:maintenance:config')
+    if (data) {
+      return JSON.parse(data)
+    }
+    return { autoCleanup: false, retentionDays: 30 }
+  }
+
+  /**
+   * Save maintenance configuration
+   */
+  async saveConfig(config: MaintenanceConfig): Promise<void> {
+    await this.redis.set('gravito:zenith:maintenance:config', JSON.stringify(config))
+  }
+}

package/src/server/services/PulseService.ts

@@ -1,6 +1,15 @@
 import { Redis } from 'ioredis'
 import type { PulseNode } from '../../shared/types'
 
+/**
+ * PulseService manages the discovery and health monitoring of system nodes.
+ *
+ * It scans Redis for heartbeat keys emitted by Quasar agents and groups
+ * them by service name for the Zenith dashboard.
+ *
+ * @public
+ * @since 3.0.0
+ */
 export class PulseService {
   private redis: Redis
   private prefix = 'gravito:quasar:node:'
@@ -55,7 +64,9 @@ export class PulseService {
     // Sort nodes by service name, then by node id for stable UI positions
     nodes.sort((a, b) => {
       const sComp = a.service.localeCompare(b.service)
-      if (sComp !== 0) return sComp
+      if (sComp !== 0) {
+        return sComp
+      }
       return a.id.localeCompare(b.id)
     })
 

package/src/server/services/QueueMetricsCollector.ts

@@ -0,0 +1,138 @@
+import type { Redis } from 'ioredis'
+import type { GlobalStats, QueueStats, WorkerReport } from './QueueService'
+
+export class QueueMetricsCollector {
+  constructor(
+    private redis: Redis,
+    private prefix = 'queue:'
+  ) {}
+
+  /**
+   * Discover all queues using SCAN to avoid blocking Redis
+   */
+  async listQueues(): Promise<QueueStats[]> {
+    const queues = new Set<string>()
+    let cursor = '0'
+    let iterations = 0
+    const MAX_ITERATIONS = 1000
+
+    do {
+      const result = await this.redis.scan(cursor, 'MATCH', `${this.prefix}*`, 'COUNT', 100)
+      cursor = result[0]
+      const keys = result[1]
+
+      for (const key of keys) {
+        const relative = key.slice(this.prefix.length)
+        const parts = relative.split(':')
+        const candidateName = parts[0]
+
+        if (candidateName && !this.isSystemKey(candidateName)) {
+          queues.add(candidateName)
+        }
+      }
+
+      iterations++
+    } while (cursor !== '0' && iterations < MAX_ITERATIONS)
+
+    return this.collectQueueStats(Array.from(queues).sort())
+  }
+
+  /**
+   * Collect statistics for a list of queues
+   */
+  private async collectQueueStats(queueNames: string[]): Promise<QueueStats[]> {
+    const stats: QueueStats[] = []
+    const BATCH_SIZE = 10
+
+    for (let i = 0; i < queueNames.length; i += BATCH_SIZE) {
+      const batch = queueNames.slice(i, i + BATCH_SIZE)
+      const batchResults = await Promise.all(batch.map(async (name) => this.getQueueStats(name)))
+      stats.push(...batchResults)
+    }
+
+    return stats
+  }
+
+  /**
+   * Get statistics for a single queue
+   */
+  private async getQueueStats(name: string): Promise<QueueStats> {
+    const waiting = await this.redis.llen(`${this.prefix}${name}`)
+    const delayed = await this.redis.zcard(`${this.prefix}${name}:delayed`)
+    const failed = await this.redis.llen(`${this.prefix}${name}:failed`)
+    const active = await this.redis.scard(`${this.prefix}${name}:active`)
+    const paused = await this.redis.get(`${this.prefix}${name}:paused`)
+
+    return {
+      name,
+      waiting,
+      delayed,
+      failed,
+      active,
+      paused: paused === '1',
+    }
+  }
+
+  /**
+   * Get global statistics including throughput
+   */
+  async getGlobalStats(): Promise<GlobalStats> {
+    const queues = await this.listQueues()
+    const throughput = await this.getThroughputData()
+
+    return {
+      queues,
+      throughput,
+      workers: [],
+    }
+  }
+
+  /**
+   * Get throughput data for the last hour
+   */
+  private async getThroughputData(): Promise<{ timestamp: string; count: number }[]> {
+    const data: { timestamp: string; count: number }[] = []
+    const currentMinute = Math.floor(Date.now() / 60000)
+
+    for (let i = 0; i < 60; i++) {
+      const minute = currentMinute - i
+      const count = await this.redis.get(`flux_console:throughput:${minute}`)
+      data.push({
+        timestamp: new Date(minute * 60000).toISOString(),
+        count: Number(count) || 0,
+      })
+    }
+
+    return data.reverse()
+  }
+
+  /**
+   * Get reports from all active workers
+   */
+  async listWorkers(): Promise<WorkerReport[]> {
+    const workers = await this.redis.smembers('flux_console:workers')
+
+    return Promise.all(workers.map(async (workerId) => this.getWorkerReport(workerId)))
+  }
+
+  /**
+   * Get report from a specific worker
+   */
+  private async getWorkerReport(workerId: string): Promise<WorkerReport> {
+    const data = await this.redis.get(`flux_console:worker:${workerId}`)
+
+    if (!data) {
+      throw new Error(`Worker ${workerId} not found`)
+    }
+
+    return JSON.parse(data) as WorkerReport
+  }
+
+  /**
+   * Check if a key is a system key
+   */
+  private isSystemKey(key: string): boolean {
+    const systemKeys = ['active', 'schedules', 'schedule', 'lock']
+    return systemKeys.includes(key)
+  }
+}