@gravito/zenith 1.1.2 → 1.1.6

package/src/server/middleware/auth.ts

@@ -1,127 +0,0 @@
-import type { Context, Next } from 'hono'
-import { deleteCookie, getCookie, setCookie } from 'hono/cookie'
-
-// Session token store (in-memory for simplicity, consider Redis for production)
-const sessions = new Map<string, { createdAt: number; expiresAt: number }>()
-
-// Configuration
-const SESSION_DURATION_MS = 24 * 60 * 60 * 1000 // 24 hours
-const SESSION_COOKIE_NAME = 'flux_session'
-
-/**
- * Generate a secure random session token
- */
-function generateSessionToken(): string {
-  const array = new Uint8Array(32)
-  crypto.getRandomValues(array)
-  return Array.from(array, (byte) => byte.toString(16).padStart(2, '0')).join('')
-}
-
-/**
- * Check if authentication is enabled
- */
-export function isAuthEnabled(): boolean {
-  return !!process.env.AUTH_PASSWORD
-}
-
-/**
- * Verify the provided password against the environment variable
- */
-export function verifyPassword(password: string): boolean {
-  const authPassword = process.env.AUTH_PASSWORD
-  if (!authPassword) {
-    return true // No password set, allow access
-  }
-  return password === authPassword
-}
-
-/**
- * Create a new session and set the cookie
- */
-export function createSession(c: Context): string {
-  const token = generateSessionToken()
-  const now = Date.now()
-
-  sessions.set(token, {
-    createdAt: now,
-    expiresAt: now + SESSION_DURATION_MS,
-  })
-
-  setCookie(c, SESSION_COOKIE_NAME, token, {
-    httpOnly: true,
-    secure: process.env.NODE_ENV === 'production',
-    sameSite: 'Lax',
-    maxAge: SESSION_DURATION_MS / 1000,
-    path: '/',
-  })
-
-  return token
-}
-
-/**
- * Validate a session token
- */
-export function validateSession(token: string): boolean {
-  const session = sessions.get(token)
-  if (!session) {
-    return false
-  }
-
-  if (Date.now() > session.expiresAt) {
-    sessions.delete(token)
-    return false
-  }
-
-  return true
-}
-
-/**
- * Destroy a session
- */
-export function destroySession(c: Context): void {
-  const token = getCookie(c, SESSION_COOKIE_NAME)
-  if (token) {
-    sessions.delete(token)
-  }
-  deleteCookie(c, SESSION_COOKIE_NAME, { path: '/' })
-}
-
-/**
- * Authentication middleware for API routes
- */
-export async function authMiddleware(c: Context, next: Next) {
-  // If no password is set, allow all requests
-  if (!isAuthEnabled()) {
-    return next()
-  }
-
-  // Allow auth endpoints without authentication
-  const path = c.req.path
-  if (path === '/api/auth/login' || path === '/api/auth/status' || path === '/api/auth/logout') {
-    return next()
-  }
-
-  // Check for valid session
-  const token = getCookie(c, SESSION_COOKIE_NAME)
-  if (token && validateSession(token)) {
-    return next()
-  }
-
-  // Unauthorized
-  return c.json({ error: 'Unauthorized', message: 'Please login to access this resource' }, 401)
-}
-
-/**
- * Clean up expired sessions periodically
- */
-export function cleanupExpiredSessions(): void {
-  const now = Date.now()
-  for (const [token, session] of sessions) {
-    if (now > session.expiresAt) {
-      sessions.delete(token)
-    }
-  }
-}
-
-// Run cleanup every 10 minutes
-setInterval(cleanupExpiredSessions, 10 * 60 * 1000)

package/src/server/services/AlertService.ts

@@ -1,321 +0,0 @@
-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[] = []
-  private config: AlertConfig = { channels: {} }
-  private cooldowns: Map<string, number> = new Map()
-  private emitter = new EventEmitter()
-  private readonly RULES_KEY = 'gravito:zenith:alerts:rules'
-  private readonly CONFIG_KEY = 'gravito:zenith:alerts:config'
-
-  constructor(redisUrl: string) {
-    this.redis = new Redis(redisUrl, {
-      lazyConnect: true,
-    })
-
-    // Initial default rules
-    this.rules = [
-      {
-        id: 'global_failure_spike',
-        name: 'High Failure Rate',
-        type: 'failure',
-        threshold: 50,
-        cooldownMinutes: 30,
-      },
-      {
-        id: 'global_backlog_critical',
-        name: 'Queue Backlog Warning',
-        type: 'backlog',
-        threshold: 1000,
-        cooldownMinutes: 60,
-      },
-      {
-        id: 'no_workers_online',
-        name: 'All Workers Offline',
-        type: 'worker_lost',
-        threshold: 1,
-        cooldownMinutes: 15,
-      },
-    ]
-
-    // Default configuration (with env fallback for Slack)
-    if (process.env.SLACK_WEBHOOK_URL) {
-      this.config.channels.slack = {
-        enabled: true,
-        webhookUrl: process.env.SLACK_WEBHOOK_URL,
-      }
-    }
-
-    this.init().catch((err) => console.error('[AlertService] Failed to initialize:', err))
-  }
-
-  async connect() {
-    if (this.redis.status === 'wait') {
-      await this.redis.connect()
-    }
-  }
-
-  private async init() {
-    await this.loadRules()
-    await this.loadConfig()
-  }
-
-  async loadRules() {
-    try {
-      const data = await this.redis.get(this.RULES_KEY)
-      if (data) {
-        this.rules = JSON.parse(data)
-      }
-    } catch (err) {
-      console.error('[AlertService] Error loading rules from Redis:', err)
-    }
-  }
-
-  async loadConfig() {
-    try {
-      const data = await this.redis.get(this.CONFIG_KEY)
-      if (data) {
-        this.config = JSON.parse(data)
-      }
-    } catch (err) {
-      console.error('[AlertService] Error loading config from Redis:', err)
-    }
-  }
-
-  async saveRules(rules: AlertRule[]) {
-    this.rules = rules
-    await this.redis.set(this.RULES_KEY, JSON.stringify(rules))
-  }
-
-  async saveConfig(config: AlertConfig) {
-    this.config = config
-    await this.redis.set(this.CONFIG_KEY, JSON.stringify(config))
-  }
-
-  async addRule(rule: AlertRule) {
-    this.rules.push(rule)
-    await this.saveRules(this.rules)
-  }
-
-  async deleteRule(id: string) {
-    this.rules = this.rules.filter((r) => r.id !== id)
-    await this.saveRules(this.rules)
-  }
-
-  onAlert(callback: (event: AlertEvent) => void) {
-    this.emitter.on('alert', callback)
-    return () => this.emitter.off('alert', callback)
-  }
-
-  /**
-   * Evaluates rules against provided data.
-   */
-  async check(data: {
-    queues: any[]
-    nodes: Record<string, PulseNode[]>
-    workers: WorkerReport[]
-    totals: { waiting: number; delayed: number; failed: number }
-  }) {
-    const now = Date.now()
-
-    for (const rule of this.rules) {
-      // 1. Check Cool-down
-      const lastFire = this.cooldowns.get(rule.id) || 0
-      if (now - lastFire < rule.cooldownMinutes * 60 * 1000) {
-        continue
-      }
-
-      let fired = false
-      let message = ''
-      let severity: 'warning' | 'critical' = 'warning'
-
-      // 2. Evaluate Rule
-      switch (rule.type) {
-        case 'backlog': {
-          const targetValue = rule.queue
-            ? data.queues.find((q) => q.name === rule.queue)?.waiting || 0
-            : data.totals.waiting
-
-          if (targetValue >= rule.threshold) {
-            fired = true
-            severity = 'critical'
-            message = rule.queue
-              ? `Queue backlog on ${rule.queue}: ${targetValue} jobs waiting.`
-              : `Queue backlog detected: ${targetValue} jobs waiting across all queues.`
-          }
-          break
-        }
-
-        case 'failure': {
-          const targetValue = rule.queue
-            ? data.queues.find((q) => q.name === rule.queue)?.failed || 0
-            : data.totals.failed
-
-          if (targetValue >= rule.threshold) {
-            fired = true
-            severity = 'warning'
-            message = rule.queue
-              ? `High failure count on ${rule.queue}: ${targetValue} jobs failed.`
-              : `High failure count: ${targetValue} jobs are currently in failed state.`
-          }
-          break
-        }
-
-        case 'worker_lost':
-          if (data.workers.length < rule.threshold) {
-            fired = true
-            severity = 'critical'
-            message = `System Incident: Zero worker nodes detected! Jobs will not be processed.`
-          }
-          break
-
-        case 'node_cpu':
-          // Check all pulse nodes
-          for (const serviceNodes of Object.values(data.nodes)) {
-            for (const node of serviceNodes) {
-              if (node.cpu.process >= rule.threshold) {
-                fired = true
-                severity = 'warning'
-                message = `High CPU Usage on ${node.service} (${node.id}): ${node.cpu.process}%`
-                break
-              }
-            }
-            if (fired) {
-              break
-            }
-          }
-          break
-
-        case 'node_ram':
-          for (const serviceNodes of Object.values(data.nodes)) {
-            for (const node of serviceNodes) {
-              const usagePercent = (node.memory.process.rss / node.memory.system.total) * 100
-              if (usagePercent >= rule.threshold) {
-                fired = true
-                severity = 'warning'
-                message = `High RAM Usage on ${node.service} (${node.id}): ${usagePercent.toFixed(1)}%`
-                break
-              }
-            }
-            if (fired) {
-              break
-            }
-          }
-          break
-      }
-
-      // 3. Dispatch if fired
-      if (fired) {
-        this.cooldowns.set(rule.id, now)
-        const event: AlertEvent = {
-          ruleId: rule.id,
-          timestamp: now,
-          message,
-          severity,
-        }
-
-        this.emitter.emit('alert', event)
-        this.notify(event)
-      }
-    }
-  }
-
-  private async notify(event: AlertEvent) {
-    const { slack, discord, email } = this.config.channels
-
-    // 1. Notify Slack
-    if (slack?.enabled && slack.webhookUrl) {
-      this.sendToWebhook(slack.webhookUrl, 'Slack', event).catch(console.error)
-    }
-
-    // 2. Notify Discord
-    if (discord?.enabled && discord.webhookUrl) {
-      this.sendToWebhook(discord.webhookUrl, 'Discord', event).catch(console.error)
-    }
-
-    // 3. Notify Email
-    if (email?.enabled) {
-      this.sendEmail(email, event).catch(console.error)
-    }
-  }
-
-  private async sendToWebhook(url: string, platform: string, event: AlertEvent) {
-    const payload = {
-      text: `*Flux Console Alert [${event.severity.toUpperCase()}]*\n${event.message}\n_Time: ${new Date(event.timestamp).toISOString()}_`,
-      attachments: [
-        {
-          color: event.severity === 'critical' ? '#ef4444' : '#f59e0b',
-          fields: [
-            { title: 'Rule', value: event.ruleId, short: true },
-            { title: 'Severity', value: event.severity, short: true },
-            { title: 'Platform', value: platform, short: true },
-          ],
-        },
-      ],
-    }
-
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload),
-    })
-
-    if (!res.ok) {
-      throw new Error(`Failed to send to ${platform}: ${await res.text()}`)
-    }
-  }
-
-  private async sendEmail(config: any, event: AlertEvent) {
-    const transporter = nodemailer.createTransport({
-      host: config.smtpHost,
-      port: config.smtpPort,
-      secure: config.smtpPort === 465,
-      auth: {
-        user: config.smtpUser,
-        pass: config.smtpPass,
-      },
-    })
-
-    await transporter.sendMail({
-      from: config.from,
-      to: config.to,
-      subject: `[Zenith Alert] ${event.severity.toUpperCase()}: ${event.ruleId}`,
-      text: `${event.message}\n\nTimestamp: ${new Date(event.timestamp).toISOString()}\nSeverity: ${event.severity}`,
-      html: `
-        <div style="font-family: sans-serif; padding: 20px; border: 1px solid #eee; border-radius: 10px;">
-          <h2 style="color: ${event.severity === 'critical' ? '#ef4444' : '#f59e0b'}">
-            Zenith Alert: ${event.severity.toUpperCase()}
-          </h2>
-          <p style="font-size: 16px;">${event.message}</p>
-          <hr />
-          <p style="font-size: 12px; color: #666;">
-            Rule ID: ${event.ruleId}<br />
-            Time: ${new Date(event.timestamp).toISOString()}
-          </p>
-        </div>
-      `,
-    })
-  }
-
-  getRules() {
-    return this.rules
-  }
-
-  getConfig() {
-    return this.config
-  }
-}

package/src/server/services/CommandService.ts

@@ -1,137 +0,0 @@
-import type { CommandType, QuasarCommand } from '@gravito/quasar'
-import { Redis } from 'ioredis'
-
-/**
- * CommandService handles sending commands from Zenith to Quasar agents.
- *
- * This is the "control center" that publishes commands to Redis Pub/Sub.
- * Agents subscribe and execute commands locally.
- */
-export class CommandService {
-  private redis: Redis
-
-  constructor(redisUrl: string) {
-    this.redis = new Redis(redisUrl, {
-      lazyConnect: true,
-    })
-  }
-
-  async connect(): Promise<void> {
-    if (this.redis.status !== 'ready' && this.redis.status !== 'connecting') {
-      await this.redis.connect()
-    }
-  }
-
-  /**
-   * Send a command to a specific Quasar agent.
-   *
-   * @param service - Target service name
-   * @param nodeId - Target node ID (or '*' for broadcast)
-   * @param type - Command type
-   * @param payload - Command payload
-   * @returns Command ID
-   */
-  async sendCommand(
-    service: string,
-    nodeId: string,
-    type: CommandType,
-    payload: QuasarCommand['payload']
-  ): Promise<string> {
-    const commandId = crypto.randomUUID()
-
-    const command: QuasarCommand = {
-      id: commandId,
-      type,
-      targetNodeId: nodeId,
-      payload,
-      timestamp: Date.now(),
-      issuer: 'zenith',
-    }
-
-    const channel = `gravito:quasar:cmd:${service}:${nodeId}`
-
-    await this.redis.publish(channel, JSON.stringify(command))
-
-    console.log(`[CommandService] 📤 Sent ${type} to ${channel}`)
-    return commandId
-  }
-
-  /**
-   * Retry a job on a specific node.
-   */
-  async retryJob(
-    service: string,
-    nodeId: string,
-    queue: string,
-    jobKey: string,
-    driver: 'redis' | 'laravel' = 'redis'
-  ): Promise<string> {
-    return this.sendCommand(service, nodeId, 'RETRY_JOB', {
-      queue,
-      jobKey,
-      driver,
-    })
-  }
-
-  /**
-   * Delete a job on a specific node.
-   */
-  async deleteJob(
-    service: string,
-    nodeId: string,
-    queue: string,
-    jobKey: string,
-    driver: 'redis' | 'laravel' = 'redis'
-  ): Promise<string> {
-    return this.sendCommand(service, nodeId, 'DELETE_JOB', {
-      queue,
-      jobKey,
-      driver,
-    })
-  }
-
-  /**
-   * Broadcast a retry command to all nodes of a service.
-   */
-  async broadcastRetryJob(
-    service: string,
-    queue: string,
-    jobKey: string,
-    driver: 'redis' | 'laravel' = 'redis'
-  ): Promise<string> {
-    return this.retryJob(service, '*', queue, jobKey, driver)
-  }
-
-  /**
-   * Broadcast a delete command to all nodes of a service.
-   */
-  async broadcastDeleteJob(
-    service: string,
-    queue: string,
-    jobKey: string,
-    driver: 'redis' | 'laravel' = 'redis'
-  ): Promise<string> {
-    return this.deleteJob(service, '*', queue, jobKey, driver)
-  }
-
-  /**
-   * Send a Laravel-specific action (retry-all, restart) to a node.
-   */
-  async laravelAction(
-    service: string,
-    nodeId: string,
-    action: 'retry-all' | 'restart' | 'retry',
-    jobId?: string
-  ): Promise<string> {
-    return this.sendCommand(service, nodeId, 'LARAVEL_ACTION', {
-      queue: 'default',
-      jobKey: '*',
-      action,
-      jobId,
-    })
-  }
-
-  async disconnect(): Promise<void> {
-    await this.redis.quit()
-  }
-}

package/src/server/services/LogStreamProcessor.ts

@@ -1,93 +0,0 @@
-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
-  }
-}