@gravito/zenith 1.1.2 → 1.1.6

package/scripts/seed.ts

@@ -1,213 +0,0 @@
-#!/usr/bin/env bun
-import { Job, QueueManager } from '@gravito/stream'
-import Redis from 'ioredis'
-
-/**
- * Flux Console Unified Seed Script
- *
- * Usage:
- *   bun scripts/seed.ts [mode]
- *
- * Modes:
- *   standard  - Small set of diverse jobs (Waiting, Delayed, Failed)
- *   stress    - Many queues and many jobs for performance testing
- *   batch     - Setup for batch operation testing (100+ jobs)
- *   cron      - Register recurring schedules
- *   cleanup   - Flush Redis and clear logs
- */
-
-const mode = process.argv[2] || 'standard'
-const redis = new Redis('redis://localhost:6379')
-const prefix = 'queue:'
-
-// Simple Job class for testing
-class GenericJob extends Job {
-  constructor(
-    id: any = null,
-    public data: any = {}
-  ) {
-    super()
-    this.id = id
-  }
-  async handle() {}
-}
-
-const manager = new QueueManager({
-  default: 'redis',
-  connections: {
-    redis: {
-      driver: 'redis',
-      client: redis,
-      prefix,
-    },
-  },
-})
-
-manager.registerJobClasses([GenericJob])
-
-async function cleanup() {
-  console.log('🧹 Cleaning up Redis...')
-  const keys = await redis.keys(`${prefix}*`)
-  const internalKeys = await redis.keys('flux_console:*')
-  const allKeys = [...keys, ...internalKeys]
-
-  if (allKeys.length > 0) {
-    await redis.del(...allKeys)
-  }
-  console.log(`✅ Removed ${allKeys.length} keys.`)
-}
-
-async function seedStandard() {
-  console.log('🚀 Seeding standard data...')
-
-  // Orders Queue
-  for (let i = 1; i <= 5; i++) {
-    const job = new GenericJob(`ORD-${1000 + i}`, { amount: Math.random() * 100 })
-    job.queueName = 'orders'
-    await manager.push(job)
-  }
-
-  // Failed Jobs
-  for (let i = 1; i <= 3; i++) {
-    const jobInstance = new GenericJob(`FAIL-${i}`, { error: 'Payment Timeout' })
-    jobInstance.queueName = 'orders'
-    const serialized = manager.getSerializer().serialize(jobInstance)
-
-    await redis.lpush(
-      `${prefix}orders:failed`,
-      JSON.stringify({
-        ...serialized,
-        status: 'failed',
-        failedReason: 'Payment Timeout',
-        failedAt: Date.now(),
-      })
-    )
-  }
-
-  // Delayed Jobs
-  for (let i = 1; i <= 3; i++) {
-    const job = new GenericJob(`DLY-${i}`, { type: 'reminder' })
-    job.queueName = 'notifications'
-    job.delay(3600 * 1000) // 1 hour
-    await manager.push(job)
-  }
-}
-
-async function seedStress() {
-  console.log('🔥 Stress Mode: Creating 15 queues with jobs...')
-  const queues = [
-    'billing',
-    'shipping',
-    'inventory',
-    'marketing',
-    'crm',
-    'auth',
-    'logs',
-    'backups',
-    'indexing',
-    'cache',
-    'sync',
-    'webhooks',
-    'api',
-    'metrics',
-    'events',
-  ]
-
-  for (const q of queues) {
-    const count = 10 + Math.floor(Math.random() * 40)
-    for (let i = 0; i < count; i++) {
-      const job = new GenericJob(`JOB-${q}-${i}`, { timestamp: Date.now() })
-      job.queueName = q
-      await manager.push(job)
-    }
-    console.log(`  - ${q}: ${count} jobs`)
-  }
-}
-
-async function seedBatch() {
-  console.log('📦 Batch Mode: Setting up specialized data for batch testing...')
-
-  // 100 Waiting jobs
-  for (let i = 1; i <= 100; i++) {
-    const job = new GenericJob(`BATCH-WAIT-${i}`)
-    job.queueName = 'test-batch'
-    await manager.push(job)
-  }
-
-  // 50 Failed jobs
-  for (let i = 1; i <= 50; i++) {
-    const jobInstance = new GenericJob(`BATCH-FAIL-${i}`, { error: 'Database Connection Lost' })
-    jobInstance.queueName = 'test-batch-fail'
-    const serialized = manager.getSerializer().serialize(jobInstance)
-
-    await redis.lpush(
-      `${prefix}test-batch-fail:failed`,
-      JSON.stringify({
-        ...serialized,
-        status: 'failed',
-        attempts: 3,
-        failedAt: Date.now(),
-      })
-    )
-  }
-}
-
-async function seedCron() {
-  console.log('⏰ Cron Mode: Registering recurring schedules...')
-  const scheduler = manager.getScheduler()
-  const serializer = manager.getSerializer()
-
-  const rawSchedules = [
-    { id: 'cleanup-tmp', cron: '*/1 * * * *', queue: 'system', name: 'CleanupTmp' },
-    { id: 'daily-report', cron: '0 0 * * *', queue: 'reports', name: 'DailyReport' },
-    { id: 'health-check', cron: '*/5 * * * *', queue: 'monitoring', name: 'HealthCheck' },
-    { id: 'high-frequency', cron: '*/1 * * * *', queue: 'fast', name: 'Pulse' },
-  ]
-
-  for (const s of rawSchedules) {
-    const jobInstance = new GenericJob(s.id, { task: s.name })
-    jobInstance.queueName = s.queue
-    const serialized = serializer.serialize(jobInstance)
-
-    await scheduler.register({
-      id: s.id,
-      cron: s.cron,
-      queue: s.queue,
-      job: serialized,
-    })
-    console.log(`  - Registered: ${s.id} (${s.cron})`)
-  }
-}
-
-async function main() {
-  try {
-    if (mode === 'cleanup') {
-      await cleanup()
-    } else if (mode === 'standard') {
-      await cleanup()
-      await seedStandard()
-    } else if (mode === 'stress') {
-      await seedStress()
-    } else if (mode === 'batch') {
-      await seedBatch()
-    } else if (mode === 'cron') {
-      await seedCron()
-    } else if (mode === 'all') {
-      await cleanup()
-      await seedStandard()
-      await seedStress()
-      await seedBatch()
-      await seedCron()
-    } else {
-      console.log('❌ Unknown mode. Try: standard, stress, batch, cron, cleanup, all')
-    }
-  } catch (err) {
-    console.error('💥 Error:', err)
-  } finally {
-    redis.disconnect()
-    console.log('\n🏁 Done.')
-    process.exit(0)
-  }
-}
-
-main()

package/scripts/verify-throttle.ts

@@ -1,49 +0,0 @@
-console.log('🎧 Connecting to log stream...')
-const req = await fetch('http://localhost:3000/api/logs/stream')
-if (!req.body) {
-  throw new Error('No body')
-}
-
-const reader = req.body.getReader()
-const decoder = new TextDecoder()
-
-let logCount = 0
-const start = Date.now()
-
-// Count for 2 seconds
-const DURATION = 2000
-
-console.log(`⏳ Measuring received logs for ${DURATION}ms...`)
-
-async function readStream() {
-  while (true) {
-    const { done, value } = await reader.read()
-    if (done) {
-      break
-    }
-
-    const chunk = decoder.decode(value)
-    // SSE format: event: log\ndata: ...\n\n
-    const matches = chunk.match(/event: log/g)
-    if (matches) {
-      logCount += matches.length
-    }
-
-    if (Date.now() - start > DURATION) {
-      break
-    }
-  }
-
-  console.log(`📊 Result: Received ${logCount} logs in ${(Date.now() - start) / 1000}s`)
-  console.log(`ℹ️  Expected max: ~50-60 logs (50/sec limit + potential buffer/history)`)
-
-  if (logCount > 150) {
-    console.error('❌ Throttling FAILED! Too many logs received.')
-    process.exit(1)
-  } else {
-    console.log('✅ Throttling PASSED!')
-    process.exit(0)
-  }
-}
-
-readStream()

package/scripts/worker.ts

@@ -1,124 +0,0 @@
-#!/usr/bin/env bun
-import { Consumer, Job, QueueManager } from '@gravito/stream'
-import Redis from 'ioredis'
-
-/**
- * Flux Console Unified Worker Script
- *
- * Usage:
- *   bun scripts/worker.ts [queues] [--fail=rate] [--delay=ms]
- *
- * Example:
- *   bun scripts/worker.ts orders,reports --fail=0.1 --delay=200
- *   bun scripts/worker.ts all
- */
-
-const redis = new Redis('redis://localhost:6379')
-const prefix = 'queue:'
-
-const queuesRaw = process.argv[2] || 'orders,notifications,test-batch,billing,analytics'
-let queues: string[] = []
-
-if (queuesRaw === 'all') {
-  console.log('🔍 Discovering all queues...')
-  const keys = await redis.keys(`${prefix}*`)
-  const set = new Set<string>()
-  for (const k of keys) {
-    const name = k.slice(prefix.length).split(':')[0]
-    // Exclude internal management keys
-    if (
-      name &&
-      ![
-        'active',
-        'schedules',
-        'schedule',
-        'worker',
-        'lock',
-        'logs',
-        'metrics',
-        'throughput',
-      ].includes(name)
-    ) {
-      set.add(name)
-    }
-  }
-  queues = Array.from(set)
-  if (queues.length === 0) {
-    console.log('⚠️ No active queues found. Defaulting to standard set...')
-    queues = ['orders', 'notifications', 'test-batch', 'billing', 'analytics']
-  }
-} else {
-  queues = queuesRaw.split(',')
-}
-
-const failRate = parseFloat(process.argv.find((a) => a.startsWith('--fail='))?.split('=')[1] || '0')
-const processDelay = parseInt(
-  process.argv.find((a) => a.startsWith('--delay='))?.split('=')[1] || '100',
-  10
-)
-
-// Simple Job class for testing
-class GenericJob extends Job {
-  constructor(
-    id: any = null,
-    public data: any = {}
-  ) {
-    super()
-    this.id = id
-  }
-  async handle() {
-    // Simulated work
-    if (processDelay > 0) {
-      await new Promise((r) => setTimeout(r, processDelay))
-    }
-
-    // Simulated failure
-    if (Math.random() < failRate) {
-      throw new Error('Simulated random failure')
-    }
-  }
-}
-
-const manager = new QueueManager({
-  default: 'redis',
-  connections: {
-    redis: {
-      driver: 'redis',
-      client: redis,
-      prefix,
-    },
-  },
-})
-
-manager.registerJobClasses([GenericJob])
-
-console.log('🚀 Starting Flux Unified Worker...')
-console.log(`📡 Queues: ${queues.join(', ')}`)
-console.log(`⚠️ Fail Rate: ${(failRate * 100).toFixed(0)}%`)
-console.log(`⏱️ Sim Delay: ${processDelay}ms\n`)
-
-const consumer = new Consumer(manager, {
-  queues,
-  connection: 'redis',
-  pollInterval: 100,
-  monitor: {
-    prefix: 'flux_console:', // Critical: match the prefix the Console looks for
-  },
-  workerOptions: {
-    maxAttempts: 3,
-  },
-})
-
-console.log('✅ Worker started. Monitoring enabled (check the Workers page in Console).')
-
-consumer.start().catch((err) => {
-  console.error('💥 Consumer Error:', err)
-  process.exit(1)
-})
-
-process.on('SIGINT', async () => {
-  console.log('\n🛑 Shutting down worker...')
-  await consumer.stop()
-  redis.disconnect()
-  process.exit(0)
-})

package/specs/PULSE_SPEC.md

@@ -1,86 +0,0 @@
-# Gravito Pulse Implementation Spec
-
-## Overview
-Gravito Pulse is a lightweight APM (Application Performance Monitoring) system integrated into Zenith. It follows the philosophy: *"If you can connect to Redis, you are monitored."*
-
-## 1. Gravito Pulse Protocol (GPP)
-
-### Data Structure
-Pulse uses Redis keys with specific TTLs to represent live services.
-
-- **Key Pattern**: `gravito:quasar:node:{service}:{node_id}`
-- **TTL**: 30 seconds (Agents should heartbeat every 10-15s).
-- **Data Type**: String (JSON)
-
-### Payload Schema
-```json
-{
-  "id": "string",          // Unique Instance ID (e.g., UUID or Hostname-PID)
-  "service": "string",     // Group name (e.g., "worker-billing", "api-gateway")
-  "language": "string",    // "node" | "bun" | "deno" | "php" | "go" | "python" | "other"
-  "version": "string",     // Language/Runtime Version
-  "pid": "number",         // Process ID
-  "hostname": "string",    // Machine Hostname or Custom Name
-  "platform": "string",    // OS Platform (linux, darwin, win32)
-  "cpu": {
-     "system": "number",   // System Load % (0-100)
-     "process": "number",  // Process Usage % (0-100)
-     "cores": "number"     // Core count
-  },
-  "memory": {
-    "system": {
-        "total": "number", // System Total Memory (bytes)
-        "free": "number",  // System Free Memory (bytes)
-        "used": "number"   // System Used Memory (bytes)
-    },
-    "process": {
-        "rss": "number",      // Resident Set Size (bytes)
-        "heapTotal": "number",// Heap Total (bytes)
-        "heapUsed": "number"  // Heap Used (bytes)
-    }
-  },
-  "runtime": {
-    "uptime": "number",    // Process uptime in seconds
-    "framework": "string"  // Optional framework info
-  },
-  "timestamp": "number"    // Unix Ms Timestamp
-}
-```
-
-## 2. Implementation Modules
-
-### A. Client SDK (`@gravito/pulse-node`)
-A lightweight agent to collect metrics and publish to Redis.
-- **Dependencies**: `ioredis`, `pidusage` (optional, or use native `os`/`process`).
-- **Functionality**:
-    - `startPulse({ service: string })`: Starts the heartbeat loop.
-    - Collects CPU/RAM usage.
-    - Publishes to Redis.
-
-### B. Server Collector (Zenith Console)
-- **Service**: `PulseService`
-- **Method**: `getNodes()`
-    - Performs `SCAN 0 MATCH pulse:* COUNT 100`.
-    - Returns grouped nodes by `service`.
-- **API**: `GET /api/pulse/nodes`
-
-### C. Frontend Dashboard (Zenith UI)
-- **Route**: `/pulse`
-- **Components**:
-    - `ServiceGroup`: A container for nodes of a specific service.
-    - `NodeCard`: Displays CPU/RAM sparklines (optional) and current health.
-    - `HealthBadge`: Green (Fresh), Yellow (>15s ago), Red (Dead/Gone - though Redis TTL handles removal, frontend can handle stale UI).
-
-## 3. Alerts (Phase 2)
-- Server-side checker that monitors values from `PulseService`.
-- Triggers `AlertService` if:
-    - CPU > 90% for 2 mins.
-    - Memory > 90% for 5 mins.
-    - Disk < 10% free.
-
-## 4. Work Plan
-1. **Define Types**: Add `PulseNode` interface to `@gravito/custom-types` or `flux-console` shared types.
-2. **Implement Server Collector**: Create `PulseService` in `packages/flux-console/server/services`.
-3. **Implement API**: Add route in `packages/flux-console/server/routes.ts`.
-4. **Implement UI**: Create `PulsePage` and components.
-5. **Implement Node Client**: Add `startPulse` to `packages/stream` (or separate package) to verify "dogfooding" by having the server monitor itself.

package/src/bin.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env bun
-import server from './server/index'
-
-console.log(`[Flux Console] CLI wrapper initialized.`)
-
-export default server

package/src/client/App.tsx

@@ -1,72 +0,0 @@
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { RefreshCcw } from 'lucide-react'
-import { BrowserRouter, Route, Routes } from 'react-router-dom'
-import { AuthProvider, useAuth } from './contexts/AuthContext'
-import { NotificationProvider } from './contexts/NotificationContext'
-import { Layout } from './Layout'
-import {
-  LoginPage,
-  MetricsPage,
-  OverviewPage,
-  PulsePage,
-  QueuesPage,
-  SchedulesPage,
-  SettingsPage,
-  WorkersPage,
-} from './pages'
-
-const queryClient = new QueryClient()
-
-function AuthenticatedRoutes() {
-  const { isAuthenticated, isAuthEnabled, isLoading } = useAuth()
-
-  // Show loading spinner while checking auth
-  if (isLoading) {
-    return (
-      <div className="min-h-screen flex items-center justify-center bg-background">
-        <div className="flex flex-col items-center gap-4">
-          <RefreshCcw className="animate-spin text-primary" size={48} />
-          <p className="text-muted-foreground font-bold uppercase tracking-[0.3em] text-xs">
-            Initializing...
-          </p>
-        </div>
-      </div>
-    )
-  }
-
-  // If auth is enabled and user is not authenticated, show login
-  if (isAuthEnabled && !isAuthenticated) {
-    return <LoginPage />
-  }
-
-  // Otherwise, show the main app
-  return (
-    <NotificationProvider>
-      <Layout>
-        <Routes>
-          <Route path="/" element={<OverviewPage />} />
-          <Route path="/queues" element={<QueuesPage />} />
-          <Route path="/schedules" element={<SchedulesPage />} />
-          <Route path="/workers" element={<WorkersPage />} />
-          <Route path="/metrics" element={<MetricsPage />} />
-          <Route path="/pulse" element={<PulsePage />} />
-          <Route path="/settings" element={<SettingsPage />} />
-        </Routes>
-      </Layout>
-    </NotificationProvider>
-  )
-}
-
-function App() {
-  return (
-    <QueryClientProvider client={queryClient}>
-      <BrowserRouter>
-        <AuthProvider>
-          <AuthenticatedRoutes />
-        </AuthProvider>
-      </BrowserRouter>
-    </QueryClientProvider>
-  )
-}
-
-export default App