bs9 1.0.0

package/src/alerting/config.ts

@@ -0,0 +1,194 @@
+#!/usr/bin/env bun
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+interface AlertConfig {
+  enabled: boolean;
+  webhookUrl?: string;
+  thresholds: {
+    cpu: number; // percentage
+    memory: number; // percentage
+    errorRate: number; // percentage
+    uptime: number; // percentage
+  };
+  cooldown: number; // seconds between alerts
+  services: {
+    [serviceName: string]: {
+      enabled: boolean;
+      customThresholds?: Partial<AlertConfig['thresholds']>;
+    };
+  };
+}
+
+class AlertManager {
+  private configPath: string;
+  private config: AlertConfig;
+  private lastAlerts: Map<string, number> = new Map();
+  
+  constructor() {
+    this.configPath = join(homedir(), ".config", "bs9", "alerts.json");
+    this.config = this.loadConfig();
+  }
+  
+  private loadConfig(): AlertConfig {
+    const defaultConfig: AlertConfig = {
+      enabled: true,
+      thresholds: {
+        cpu: 80,
+        memory: 85,
+        errorRate: 5,
+        uptime: 95,
+      },
+      cooldown: 300, // 5 minutes
+      services: {},
+    };
+    
+    if (existsSync(this.configPath)) {
+      try {
+        const content = readFileSync(this.configPath, 'utf-8');
+        return { ...defaultConfig, ...JSON.parse(content) };
+      } catch (error) {
+        console.error('Failed to load alert config, using defaults:', error);
+      }
+    }
+    
+    // Create default config file
+    this.saveConfig(defaultConfig);
+    return defaultConfig;
+  }
+  
+  private saveConfig(config: AlertConfig): void {
+    try {
+      const configDir = join(homedir(), ".config", "bs9");
+      if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+      }
+      writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+    } catch (error) {
+      console.error('Failed to save alert config:', error);
+    }
+  }
+  
+  updateConfig(updates: Partial<AlertConfig>): void {
+    this.config = { ...this.config, ...updates };
+    this.saveConfig(this.config);
+  }
+  
+  setServiceAlert(serviceName: string, enabled: boolean, customThresholds?: Partial<AlertConfig['thresholds']>): void {
+    this.config.services[serviceName] = {
+      enabled,
+      customThresholds,
+    };
+    this.saveConfig(this.config);
+  }
+  
+  async checkAlerts(serviceName: string, metrics: {
+    cpu: number;
+    memory: number;
+    health: 'healthy' | 'unhealthy' | 'unknown';
+    uptime: number;
+  }): Promise<void> {
+    if (!this.config.enabled) return;
+    
+    const serviceConfig = this.config.services[serviceName];
+    if (serviceConfig && !serviceConfig.enabled) return;
+    
+    const thresholds = {
+      ...this.config.thresholds,
+      ...serviceConfig?.customThresholds,
+    };
+    
+    const alerts: string[] = [];
+    
+    // Check CPU threshold
+    if (metrics.cpu > thresholds.cpu) {
+      alerts.push(`CPU usage (${metrics.cpu}%) exceeds threshold (${thresholds.cpu}%)`);
+    }
+    
+    // Check Memory threshold
+    if (metrics.memory > thresholds.memory) {
+      alerts.push(`Memory usage (${metrics.memory}%) exceeds threshold (${thresholds.memory}%)`);
+    }
+    
+    // Check Uptime threshold
+    if (metrics.uptime < thresholds.uptime) {
+      alerts.push(`Uptime (${metrics.uptime}%) below threshold (${thresholds.uptime}%)`);
+    }
+    
+    // Check health
+    if (metrics.health === 'unhealthy') {
+      alerts.push('Service health check failed');
+    }
+    
+    if (alerts.length === 0) return;
+    
+    // Check cooldown
+    const now = Date.now();
+    const lastAlert = this.lastAlerts.get(serviceName) || 0;
+    
+    if (now - lastAlert < this.config.cooldown * 1000) {
+      return; // Still in cooldown period
+    }
+    
+    // Send alert
+    await this.sendAlert(serviceName, alerts);
+    this.lastAlerts.set(serviceName, now);
+  }
+  
+  private async sendAlert(serviceName: string, alerts: string[]): Promise<void> {
+    const message = `🚨 BS9 Alert for ${serviceName}:\n${alerts.join('\n')}`;
+    
+    console.error(message);
+    
+    if (this.config.webhookUrl) {
+      try {
+        const response = await fetch(this.config.webhookUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            service: serviceName,
+            alerts,
+            timestamp: new Date().toISOString(),
+            severity: 'warning',
+          }),
+        });
+        
+        if (!response.ok) {
+          console.error(`Failed to send webhook alert: ${response.statusText}`);
+        }
+      } catch (error) {
+        console.error('Failed to send webhook alert:', error);
+      }
+    }
+  }
+  
+  getConfig(): AlertConfig {
+    return { ...this.config };
+  }
+  
+  testWebhook(): Promise<boolean> {
+    if (!this.config.webhookUrl) {
+      return Promise.resolve(false);
+    }
+    
+    return fetch(this.config.webhookUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        test: true,
+        message: 'BS9 Alert System Test',
+        timestamp: new Date().toISOString(),
+      }),
+    })
+    .then(response => response.ok)
+    .catch(() => false);
+  }
+}
+
+export { AlertManager, AlertConfig };

package/src/commands/alert.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env bun
+
+import { AlertManager } from "../alerting/config.js";
+
+interface AlertOptions {
+  enable?: boolean;
+  disable?: boolean;
+  webhook?: string;
+  cpu?: string;
+  memory?: string;
+  errorRate?: string;
+  uptime?: string;
+  cooldown?: string;
+  service?: string;
+  list?: boolean;
+  test?: boolean;
+}
+
+export async function alertCommand(options: AlertOptions): Promise<void> {
+  const alertManager = new AlertManager();
+  
+  if (options.list) {
+    const config = alertManager.getConfig();
+    console.log('🔔 BS9 Alert Configuration');
+    console.log('='.repeat(40));
+    console.log(`Enabled: ${config.enabled}`);
+    if (config.webhookUrl) {
+      console.log(`Webhook: ${config.webhookUrl}`);
+    }
+    console.log('');
+    console.log('Thresholds:');
+    console.log(`  CPU: ${config.thresholds.cpu}%`);
+    console.log(`  Memory: ${config.thresholds.memory}%`);
+    console.log(`  Error Rate: ${config.thresholds.errorRate}%`);
+    console.log(`  Uptime: ${config.thresholds.uptime}%`);
+    console.log(`  Cooldown: ${config.cooldown}s`);
+    console.log('');
+    
+    if (Object.keys(config.services).length > 0) {
+      console.log('Service-specific configs:');
+      for (const [serviceName, serviceConfig] of Object.entries(config.services)) {
+        console.log(`  ${serviceName}:`);
+        console.log(`    Enabled: ${serviceConfig.enabled}`);
+        if (serviceConfig.customThresholds) {
+          console.log(`    Custom thresholds:`, serviceConfig.customThresholds);
+        }
+      }
+    }
+    return;
+  }
+  
+  if (options.test) {
+    console.log('🧪 Testing alert webhook...');
+    const success = await alertManager.testWebhook();
+    if (success) {
+      console.log('✅ Webhook test successful');
+    } else {
+      console.log('❌ Webhook test failed');
+    }
+    return;
+  }
+  
+  const updates: any = {};
+  
+  if (options.enable !== undefined) {
+    updates.enabled = options.enable;
+  }
+  
+  if (options.webhook) {
+    updates.webhookUrl = options.webhook;
+  }
+  
+  const thresholdUpdates: any = {};
+  if (options.cpu) thresholdUpdates.cpu = Number(options.cpu);
+  if (options.memory) thresholdUpdates.memory = Number(options.memory);
+  if (options.errorRate) thresholdUpdates.errorRate = Number(options.errorRate);
+  if (options.uptime) thresholdUpdates.uptime = Number(options.uptime);
+  if (options.cooldown) thresholdUpdates.cooldown = Number(options.cooldown);
+  
+  if (Object.keys(thresholdUpdates).length > 0) {
+    updates.thresholds = {
+      ...alertManager.getConfig().thresholds,
+      ...thresholdUpdates,
+    };
+  }
+  
+  if (options.service) {
+    const serviceName = options.service;
+    const enabled = options.enable !== false;
+    alertManager.setServiceAlert(serviceName, enabled, Object.keys(thresholdUpdates).length > 0 ? thresholdUpdates : undefined);
+    console.log(`✅ Updated alert config for service: ${serviceName}`);
+  } else if (Object.keys(updates).length > 0) {
+    alertManager.updateConfig(updates);
+    console.log('✅ Updated global alert configuration');
+  } else {
+    console.log('ℹ️  No changes specified. Use --help for options.');
+  }
+}

package/src/commands/export.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env bun
+
+import { MetricsStorage } from "../storage/metrics.js";
+import { writeFileSync } from "node:fs";
+
+interface ExportOptions {
+  format?: string;
+  hours?: string;
+  output?: string;
+  service?: string;
+}
+
+export async function exportCommand(options: ExportOptions): Promise<void> {
+  const storage = new MetricsStorage();
+  const format = options.format || 'json';
+  const hours = Number(options.hours) || 24;
+  const serviceName = options.service;
+  
+  console.log(`📊 Exporting BS9 metrics (${format.toUpperCase()} format)`);
+  
+  try {
+    let data: string;
+    
+    if (serviceName) {
+      // Export specific service metrics
+      const serviceMetrics = storage.getServiceMetrics(serviceName, hours);
+      data = format === 'csv' ? serviceMetricsToCsv(serviceMetrics, serviceName) : JSON.stringify(serviceMetrics, null, 2);
+      console.log(`📈 Exporting metrics for service: ${serviceName}`);
+    } else {
+      // Export all metrics
+      data = storage.exportData(format as 'json' | 'csv');
+      console.log(`📈 Exporting all metrics for last ${hours} hours`);
+    }
+    
+    const outputFile = options.output || `bs9-metrics-${Date.now()}.${format}`;
+    writeFileSync(outputFile, data);
+    
+    console.log(`✅ Metrics exported to: ${outputFile}`);
+    console.log(`   Size: ${(data.length / 1024).toFixed(2)} KB`);
+    console.log(`   Records: ${serviceName ? storage.getServiceMetrics(serviceName, hours).length : 'all services'}`);
+    
+  } catch (error) {
+    console.error(`❌ Failed to export metrics: ${error}`);
+    process.exit(1);
+  }
+}
+
+function serviceMetricsToCsv(metrics: any[], serviceName: string): string {
+  const headers = ['timestamp', 'service_name', 'cpu_ms', 'memory_bytes', 'uptime', 'tasks', 'health', 'state'];
+  const rows = [headers.join(',')];
+  
+  for (const metric of metrics) {
+    const cpuMatch = metric.cpu.match(/([\d.]+)ms/);
+    const cpuMs = cpuMatch ? cpuMatch[1] : '0';
+    
+    rows.push([
+      new Date().toISOString(),
+      serviceName,
+      cpuMs,
+      metric.memory.toString(),
+      metric.uptime,
+      metric.tasks.toString(),
+      metric.health,
+      metric.state,
+    ].join(','));
+  }
+  
+  return rows.join('\n');
+}

package/src/commands/logs.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+
+import { execSync } from "node:child_process";
+
+interface LogsOptions {
+  follow?: boolean;
+  lines?: string;
+}
+
+export async function logsCommand(name: string, options: LogsOptions): Promise<void> {
+  try {
+    const args = ["--no-pager"];
+    if (options.follow) args.push("-f");
+    if (options.lines) args.push("-n", options.lines);
+    
+    const cmd = `journalctl --user ${args.join(" ")} -u ${name}.service`;
+    execSync(cmd, { stdio: "inherit" });
+  } catch (err) {
+    console.error(`❌ Failed to fetch logs for user service '${name}': ${err}`);
+    process.exit(1);
+  }
+}

package/src/commands/monit.ts

@@ -0,0 +1,248 @@
+#!/usr/bin/env bun
+
+import { execSync } from "node:child_process";
+import { setTimeout } from "node:timers/promises";
+
+interface MonitOptions {
+  refresh?: string;
+}
+
+interface ServiceMetrics {
+  name: string;
+  loaded: string;
+  active: string;
+  sub: string;
+  state: string;
+  cpu: string;
+  memory: string;
+  uptime: string;
+  tasks: string;
+  description: string;
+  health?: string;
+  lastError?: string;
+}
+
+export async function monitCommand(options: MonitOptions): Promise<void> {
+  const refreshInterval = Number(options.refresh) || 2;
+  
+  // Clear screen and setup
+  process.stdout.write('\x1b[2J\x1b[H');
+  console.log('🔍 BS9 Real-time Monitoring Dashboard');
+  console.log('='.repeat(80));
+  console.log(`Refresh: ${refreshInterval}s | Press Ctrl+C to exit`);
+  console.log('');
+
+  const getMetrics = (): ServiceMetrics[] => {
+    try {
+      const listOutput = execSync("systemctl --user list-units --type=service --no-pager --no-legend", { encoding: "utf-8" });
+      const lines = listOutput.split("\n").filter(line => line.includes(".service"));
+      
+      const services: ServiceMetrics[] = [];
+      
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        
+        const match = line.match(/^(?:\s*([●\s○]))?\s*([^\s]+)\.service\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+(.+)$/);
+        if (!match) continue;
+        
+        const [, statusIndicator, name, loaded, active, sub, description] = match;
+        
+        if (!description.includes("Bun Service:") && !description.includes("BS9 Service:")) continue;
+        
+        const service: ServiceMetrics = {
+          name,
+          loaded,
+          active,
+          sub,
+          state: `${active}/${sub}`,
+          description,
+          cpu: '-',
+          memory: '-',
+          uptime: '-',
+          tasks: '-',
+        };
+        
+        // Get additional metrics
+        try {
+          const showOutput = execSync(`systemctl --user show ${name} -p CPUUsageNSec MemoryCurrent ActiveEnterTimestamp TasksCurrent State`, { encoding: "utf-8" });
+          const cpuMatch = showOutput.match(/CPUUsageNSec=(\d+)/);
+          const memMatch = showOutput.match(/MemoryCurrent=(\d+)/);
+          const timeMatch = showOutput.match(/ActiveEnterTimestamp=(.+)/);
+          const tasksMatch = showOutput.match(/TasksCurrent=(\d+)/);
+          const stateMatch = showOutput.match(/State=(.+)/);
+          
+          if (cpuMatch) {
+            const cpuNs = Number(cpuMatch[1]);
+            service.cpu = `${(cpuNs / 1000000).toFixed(1)}ms`;
+          }
+          if (memMatch) {
+            const memBytes = Number(memMatch[1]);
+            service.memory = formatMemory(memBytes);
+          }
+          if (timeMatch) {
+            service.uptime = formatUptime(timeMatch[1]);
+          }
+          if (tasksMatch) {
+            service.tasks = tasksMatch[1];
+          }
+          if (stateMatch) {
+            service.state = stateMatch[1].trim();
+          }
+        } catch {
+          // Ignore metrics errors
+        }
+        
+        // Check health endpoint
+        try {
+          const portMatch = description.match(/port[=:]?\s*(\d+)/i);
+          if (portMatch) {
+            const port = portMatch[1];
+            const healthCheck = execSync(`curl -s -o /dev/null -w "%{http_code}" http://localhost:${port}/healthz`, { encoding: "utf-8", timeout: 1000 });
+            service.health = healthCheck === "200" ? "✅ OK" : "❌ FAIL";
+          }
+        } catch {
+          service.health = "⚠️  UNKNOWN";
+        }
+        
+        services.push(service);
+      }
+      
+      return services;
+    } catch (error) {
+      console.error('Error fetching metrics:', error);
+      return [];
+    }
+  };
+
+  const formatMemory = (bytes: number): string => {
+    if (bytes === 0) return '0B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))}${sizes[i]}`;
+  };
+
+  const formatUptime = (timestamp: string): string => {
+    try {
+      const date = new Date(timestamp);
+      const now = new Date();
+      const diff = now.getTime() - date.getTime();
+      
+      const hours = Math.floor(diff / (1000 * 60 * 60));
+      const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
+      
+      if (hours > 0) {
+        return `${hours}h ${minutes}m`;
+      }
+      return `${minutes}m`;
+    } catch {
+      return '-';
+    }
+  };
+
+  const renderDashboard = () => {
+    // Clear screen
+    process.stdout.write('\x1b[2J\x1b[H');
+    
+    // Header
+    console.log('🔍 BS9 Real-time Monitoring Dashboard');
+    console.log('='.repeat(120));
+    console.log(`Refresh: ${refreshInterval}s | Last update: ${new Date().toLocaleTimeString()} | Press Ctrl+C to exit`);
+    console.log('');
+    
+    const services = getMetrics();
+    
+    if (services.length === 0) {
+      console.log('No BS9-managed services running.');
+      return;
+    }
+    
+    // Table header
+    console.log('SERVICE'.padEnd(20) + 
+                'STATE'.padEnd(15) + 
+                'HEALTH'.padEnd(10) + 
+                'CPU'.padEnd(10) + 
+                'MEMORY'.padEnd(12) + 
+                'UPTIME'.padEnd(12) + 
+                'TASKS'.padEnd(8) + 
+                'DESCRIPTION');
+    console.log('-'.repeat(120));
+    
+    // Service rows
+    for (const service of services) {
+      const stateColor = service.active === 'active' ? '\x1b[32m' : '\x1b[31m';
+      const resetColor = '\x1b[0m';
+      
+      const state = `${stateColor}${service.sub}${resetColor}`;
+      const health = service.health || '-';
+      
+      console.log(
+        service.name.padEnd(20) +
+        state.padEnd(15) +
+        health.padEnd(10) +
+        service.cpu.padEnd(10) +
+        service.memory.padEnd(12) +
+        service.uptime.padEnd(12) +
+        service.tasks.padEnd(8) +
+        service.description
+      );
+    }
+    
+    // Summary
+    console.log('');
+    console.log('='.repeat(120));
+    
+    const running = services.filter(s => s.active === 'active').length;
+    const totalMemory = services.reduce((sum, s) => {
+      if (s.memory !== '-') {
+        const match = s.memory.match(/([\d.]+)(B|KB|MB|GB)/);
+        if (match) {
+          const [, value, unit] = match;
+          const bytes = Number(value) * Math.pow(1024, ['B', 'KB', 'MB', 'GB'].indexOf(unit));
+          return sum + bytes;
+        }
+      }
+      return sum;
+    }, 0);
+    
+    console.log(`📊 Summary: ${running}/${services.length} services running | Total Memory: ${formatMemory(totalMemory)} | Services: ${services.length}`);
+    
+    // Alerts
+    const failed = services.filter(s => s.active !== 'active');
+    const unhealthy = services.filter(s => s.health === '❌ FAIL');
+    
+    if (failed.length > 0 || unhealthy.length > 0) {
+      console.log('');
+      console.log('⚠️  ALERTS:');
+      if (failed.length > 0) {
+        console.log(`   Failed services: ${failed.map(s => s.name).join(', ')}`);
+      }
+      if (unhealthy.length > 0) {
+        console.log(`   Unhealthy services: ${unhealthy.map(s => s.name).join(', ')}`);
+      }
+    }
+  };
+
+  // Initial render
+  renderDashboard();
+  
+  // Setup refresh loop
+  const refresh = async () => {
+    while (true) {
+      await setTimeout(refreshInterval * 1000);
+      renderDashboard();
+    }
+  };
+  
+  // Handle Ctrl+C gracefully
+  process.on('SIGINT', () => {
+    console.log('\n👋 Monitoring stopped');
+    process.exit(0);
+  });
+  
+  // Start monitoring
+  refresh().catch(error => {
+    console.error('Monitoring error:', error);
+    process.exit(1);
+  });
+}

package/src/commands/restart.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+
+import { execSync } from "node:child_process";
+
+export async function restartCommand(name: string): Promise<void> {
+  try {
+    execSync(`systemctl --user restart ${name}`, { stdio: "inherit" });
+    console.log(`🔄 User service '${name}' restarted`);
+  } catch (err) {
+    console.error(`❌ Failed to restart user service '${name}': ${err}`);
+    process.exit(1);
+  }
+}