bs9 1.1.0 → 1.3.1

package/README.md

@@ -1,7 +1,7 @@
 # BS9 (Bun Sentinel 9) 🚀
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)](https://github.com/bs9/bs9)
+[![Version](https://img.shields.io/badge/version-1.3.0-blue.svg)](https://github.com/bs9/bs9)
 [![Security](https://img.shields.io/badge/security-Enterprise-green.svg)](SECURITY.md)
 [![Production Ready](https://img.shields.io/badge/production-Ready-brightgreen.svg)](PRODUCTION.md)
 [![Cross-Platform](https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Windows-lightgrey.svg)](https://github.com/bs9/bs9)
@@ -81,6 +81,13 @@ bs9 monit --refresh 5              # Custom refresh interval
 bs9 web --port 8080               # Start web dashboard
 bs9 web --detach --port 8080       # Run in background
 
+# Advanced monitoring
+bs9 advanced --port 8090
+
+# Performance profiling
+bs9 profile --service myapp --duration 60
+bs9 profile --service myapp --duration 60 --output profile.json
+
 # Alert management
 bs9 alert --list                   # Show alert configuration
 bs9 alert --cpu 80 --memory 85      # Set thresholds
@@ -89,6 +96,7 @@ bs9 alert --test                   # Test webhook
 
 # Historical data
 bs9 export --format json --hours 24 # Export metrics
+bs9 export --service myapp --format csv --hours 24
 bs9 export --service myapp --format csv
 ```
 

package/bin/bs9

@@ -15,7 +15,10 @@ import { profileCommand } from "../src/commands/profile.js";
 import { loadbalancerCommand } from "../src/loadbalancer/manager.js";
 import { windowsCommand } from "../src/windows/service.js";
 import { launchdCommand } from "../src/macos/launchd.js";
+import { updateCommand } from "../src/commands/update.js";
 import { dbpoolCommand } from "../src/database/pool.js";
+import { advancedMonitoringCommand } from "../src/monitoring/advanced.js";
+import { consulCommand } from "../src/discovery/consul.js";
 
 const program = new Command();
 
@@ -145,4 +148,34 @@ program
   .option("--iterations <num>", "Test iterations", "100")
   .action(dbpoolCommand);
 
+program
+  .command("update")
+  .description("Update BS9 to latest version")
+  .option("--check", "Check for updates without installing")
+  .option("--force", "Force update even if already latest")
+  .option("--rollback", "Rollback to previous version")
+  .option("--version <version>", "Update to specific version")
+  .action(updateCommand);
+
+program
+  .command("advanced")
+  .description("Advanced monitoring dashboard")
+  .option("--port <port>", "Dashboard port", "8090")
+  .action(advancedMonitoringCommand);
+
+program
+  .command("consul")
+  .description("Consul service discovery")
+  .argument("<action>", "Action to perform")
+  .option("--consul-url <url>", "Consul URL", "http://localhost:8500")
+  .option("--name <name>", "Service name")
+  .option("--id <id>", "Service ID")
+  .option("--address <address>", "Service address")
+  .option("--port <port>", "Service port")
+  .option("--tags <tags>", "Service tags (comma-separated)")
+  .option("--health-check <url>", "Health check URL")
+  .option("--meta <json>", "Service metadata (JSON)")
+  .option("--service <service>", "Service name for discovery")
+  .action(consulCommand);
+
 program.parse();

package/dist/bs9-33vcpmb9.

@@ -0,0 +1,181 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { startCommand } from "../src/commands/start.js";
+import { stopCommand } from "../src/commands/stop.js";
+import { restartCommand } from "../src/commands/restart.js";
+import { statusCommand } from "../src/commands/status.js";
+import { logsCommand } from "../src/commands/logs.js";
+import { monitCommand } from "../src/commands/monit.js";
+import { webCommand } from "../src/commands/web.js";
+import { alertCommand } from "../src/commands/alert.js";
+import { exportCommand } from "../src/commands/export.js";
+import { depsCommand } from "../src/commands/deps.js";
+import { profileCommand } from "../src/commands/profile.js";
+import { loadbalancerCommand } from "../src/loadbalancer/manager.js";
+import { windowsCommand } from "../src/windows/service.js";
+import { launchdCommand } from "../src/macos/launchd.js";
+import { updateCommand } from "../src/commands/update.js";
+import { dbpoolCommand } from "../src/database/pool.js";
+import { advancedMonitoringCommand } from "../src/monitoring/advanced.js";
+import { consulCommand } from "../src/discovery/consul.js";
+
+const program = new Command();
+
+program
+  .name("bs9")
+  .description("BS9 (Bun Sentinel 9) — Mission-critical process manager CLI")
+  .version("1.0.0");
+
+program
+  .command("start")
+  .description("Start a process with hardened systemd unit")
+  .argument("<file>", "Application file to start")
+  .option("-n, --name <name>", "Service name")
+  .option("-p, --port <port>", "Port number", "3000")
+  .option("-h, --host <host>", "Host address", "localhost")
+  .option("--https", "Use HTTPS protocol")
+  .option("-e, --env <env>", "Environment variables (can be used multiple times)", (value, previous) => [...(previous || []), value])
+  .option("--otel", "Enable OpenTelemetry instrumentation", true)
+  .option("--prometheus", "Enable Prometheus metrics", true)
+  .option("--build", "Build TypeScript to JavaScript before starting")
+  .action(startCommand);
+
+program
+  .command("stop")
+  .description("Stop a managed service")
+  .argument("<name>", "Service name")
+  .action(stopCommand);
+
+program
+  .command("restart")
+  .description("Restart a managed service")
+  .argument("<name>", "Service name")
+  .action(restartCommand);
+
+program
+  .command("status")
+  .description("Show status and SRE metrics for all services")
+  .option("-w, --watch", "Watch mode (refresh every 2s)")
+  .action(statusCommand);
+
+program
+  .command("logs")
+  .description("Show logs for a service (via journalctl)")
+  .argument("<name>", "Service name")
+  .option("-f, --follow", "Follow logs")
+  .option("-n, --lines <number>", "Number of lines", "50")
+  .action(logsCommand);
+
+program
+  .command("monit")
+  .description("Real-time terminal dashboard for all services")
+  .option("-r, --refresh <seconds>", "Refresh interval in seconds", "2")
+  .action(monitCommand);
+
+program
+  .command("web")
+  .description("Start web-based monitoring dashboard")
+  .option("-p, --port <port>", "Port for web dashboard", "8080")
+  .option("-d, --detach", "Run in background")
+  .action(webCommand);
+
+program
+  .command("alert")
+  .description("Configure alert thresholds and webhooks")
+  .option("--enable", "Enable alerts")
+  .option("--disable", "Disable alerts")
+  .option("--webhook <url>", "Set webhook URL for alerts")
+  .option("--cpu <percentage>", "CPU threshold percentage")
+  .option("--memory <percentage>", "Memory threshold percentage")
+  .option("--errorRate <percentage>", "Error rate threshold percentage")
+  .option("--uptime <percentage>", "Uptime threshold percentage")
+  .option("--cooldown <seconds>", "Alert cooldown period in seconds")
+  .option("--service <name>", "Configure alerts for specific service")
+  .option("--list", "List current alert configuration")
+  .option("--test", "Test webhook connectivity")
+  .action(alertCommand);
+
+program
+  .command("export")
+  .description("Export historical metrics data")
+  .option("-f, --format <format>", "Export format (json|csv)", "json")
+  .option("-h, --hours <hours>", "Hours of data to export", "24")
+  .option("-o, --output <file>", "Output file path")
+  .option("-s, --service <name>", "Export specific service metrics")
+  .action(exportCommand);
+
+program
+  .command("deps")
+  .description("Visualize service dependencies")
+  .option("-f, --format <format>", "Output format (text|dot|json)", "text")
+  .option("-o, --output <file>", "Output file path")
+  .action(depsCommand);
+
+program
+  .command("profile")
+  .description("Performance profiling for services")
+  .option("-d, --duration <seconds>", "Profiling duration", "60")
+  .option("-i, --interval <ms>", "Sampling interval", "1000")
+  .option("-s, --service <name>", "Service name to profile")
+  .option("-o, --output <file>", "Output file path")
+  .action(profileCommand);
+
+program
+  .command("loadbalancer")
+  .description("Load balancer management")
+  .argument("<action>", "Action to perform")
+  .option("-p, --port <port>", "Load balancer port", "8080")
+  .option("-a, --algorithm <type>", "Load balancing algorithm", "round-robin")
+  .option("-b, --backends <list>", "Backend servers (host:port,host:port)")
+  .option("--health-check", "Enable health checking", true)
+  .option("--health-path <path>", "Health check path", "/healthz")
+  .option("--health-interval <ms>", "Health check interval", "10000")
+  .action(loadbalancerCommand);
+
+program
+  .command("dbpool")
+  .description("Database connection pool management")
+  .argument("<action>", "Action to perform")
+  .option("--host <host>", "Database host", "localhost")
+  .option("--port <port>", "Database port", "5432")
+  .option("--database <name>", "Database name", "testdb")
+  .option("--username <user>", "Database username", "user")
+  .option("--password <pass>", "Database password", "password")
+  .option("--max-connections <num>", "Maximum connections", "10")
+  .option("--min-connections <num>", "Minimum connections", "2")
+  .option("--concurrency <num>", "Test concurrency", "10")
+  .option("--iterations <num>", "Test iterations", "100")
+  .action(dbpoolCommand);
+
+program
+  .command("update")
+  .description("Update BS9 to latest version")
+  .option("--check", "Check for updates without installing")
+  .option("--force", "Force update even if already latest")
+  .option("--rollback", "Rollback to previous version")
+  .option("--version <version>", "Update to specific version")
+  .action(updateCommand);
+
+program
+  .command("advanced")
+  .description("Advanced monitoring dashboard")
+  .option("--port <port>", "Dashboard port", "8090")
+  .action(advancedMonitoringCommand);
+
+program
+  .command("consul")
+  .description("Consul service discovery")
+  .argument("<action>", "Action to perform")
+  .option("--consul-url <url>", "Consul URL", "http://localhost:8500")
+  .option("--name <name>", "Service name")
+  .option("--id <id>", "Service ID")
+  .option("--address <address>", "Service address")
+  .option("--port <port>", "Service port")
+  .option("--tags <tags>", "Service tags (comma-separated)")
+  .option("--health-check <url>", "Health check URL")
+  .option("--meta <json>", "Service metadata (JSON)")
+  .option("--service <service>", "Service name for discovery")
+  .action(consulCommand);
+
+program.parse();

package/dist/bs9.js

@@ -1,2 +1,2 @@
 // @bun
-var e="./bs9-064xs9r9.";export{e as default};
+var e="./bs9-33vcpmb9.";export{e as default};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bs9",
-  "version": "1.1.0",
+  "version": "1.3.1",
   "description": "Bun Sentinel 9 - High-performance, non-root process manager for Bun",
   "type": "module",
   "main": "src/index.ts",
@@ -29,7 +29,7 @@
   "author": "xarhang",
   "license": "MIT",
   "dependencies": {
-    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api": "^1.8.0",
     "@opentelemetry/auto-instrumentations-node": "^0.50.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.50.0",
     "@opentelemetry/resources": "^1.23.0",

package/src/commands/update.ts

@@ -0,0 +1,322 @@
+#!/usr/bin/env bun
+
+import { execSync } from "node:child_process";
+import { existsSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { getPlatformInfo } from "../platform/detect.js";
+
+interface UpdateOptions {
+  check?: boolean;
+  force?: boolean;
+  rollback?: boolean;
+  version?: string;
+}
+
+interface UpdateInfo {
+  currentVersion: string;
+  latestVersion: string;
+  hasUpdate: boolean;
+  releaseNotes?: string;
+  downloadUrl?: string;
+}
+
+interface BackupInfo {
+  version: string;
+  timestamp: number;
+  files: string[];
+}
+
+class BS9Updater {
+  private configDir: string;
+  private backupDir: string;
+  private platformInfo: any;
+  
+  constructor() {
+    this.platformInfo = getPlatformInfo();
+    this.configDir = join(homedir(), '.bs9');
+    this.backupDir = join(this.configDir, 'backups');
+    this.ensureDirectories();
+  }
+  
+  private ensureDirectories(): void {
+    if (!existsSync(this.configDir)) {
+      mkdirSync(this.configDir, { recursive: true });
+    }
+    if (!existsSync(this.backupDir)) {
+      mkdirSync(this.backupDir, { recursive: true });
+    }
+  }
+  
+  private getCurrentVersion(): string {
+    try {
+      // Use the actual package.json path from the project root
+      const packageJson = join(process.cwd(), 'package.json');
+      const content = require('fs').readFileSync(packageJson, 'utf-8');
+      const pkg = JSON.parse(content);
+      return pkg.version;
+    } catch {
+      return '1.0.0'; // Fallback version
+    }
+  }
+  
+  private async getLatestVersion(): Promise<string> {
+    try {
+      const response = await fetch('https://registry.npmjs.org/bs9/latest');
+      const data = await response.json();
+      return data.version;
+    } catch (error) {
+      console.warn('⚠️  Failed to fetch latest version from npm, using fallback');
+      return '1.3.0'; // Return current version as fallback
+    }
+  }
+  
+  private compareVersions(v1: string, v2: string): number {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+    
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+      const part1 = parts1[i] || 0;
+      const part2 = parts2[i] || 0;
+      
+      if (part1 > part2) return 1;
+      if (part1 < part2) return -1;
+    }
+    
+    return 0;
+  }
+
+  public async getUpdateInfo(): Promise<UpdateInfo> {
+    const currentVersion = this.getCurrentVersion();
+    const latestVersion = await this.getLatestVersion();
+    
+    return {
+      currentVersion,
+      latestVersion,
+      hasUpdate: this.compareVersions(currentVersion, latestVersion) > 0
+    };
+  }
+  
+  private createBackup(): BackupInfo {
+    const timestamp = Date.now();
+    const currentVersion = this.getCurrentVersion();
+    const backupName = `backup-${currentVersion}-${timestamp}`;
+    const backupPath = join(this.backupDir, backupName);
+    
+    mkdirSync(backupPath, { recursive: true });
+    
+    // Backup key files
+    const filesToBackup = [
+      'bin/bs9',
+      'package.json',
+      'src',
+      'README.md',
+      'LICENSE'
+    ];
+    
+    const backedUpFiles: string[] = [];
+    
+    for (const file of filesToBackup) {
+      const sourcePath = join(process.cwd(), file);
+      const targetPath = join(backupPath, file);
+      
+      try {
+        if (existsSync(sourcePath)) {
+          execSync(`cp -r "${sourcePath}" "${targetPath}"`, { stdio: 'ignore' });
+          backedUpFiles.push(file);
+        }
+      } catch (error) {
+        console.warn(`⚠️  Failed to backup ${file}: ${error}`);
+      }
+    }
+    
+    return {
+      version: currentVersion,
+      timestamp,
+      files: backedUpFiles
+    };
+  }
+  
+  public async performUpdate(targetVersion?: string): Promise<void> {
+    console.log('🔄 Starting BS9 update...');
+    
+    // Create backup
+    console.log('📦 Creating backup...');
+    const backup = this.createBackup();
+    console.log(`✅ Backup created: ${backup.version}-${backup.timestamp}`);
+    
+    // Update package.json version
+    const packageJsonPath = join(process.cwd(), 'package.json');
+    const packageJson = JSON.parse(require('fs').readFileSync(packageJsonPath, 'utf-8'));
+    const oldVersion = packageJson.version;
+    packageJson.version = targetVersion || await this.getLatestVersion();
+    
+    require('fs').writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    console.log(`📝 Updated version: ${oldVersion} → ${packageJson.version}`);
+    
+    // Install dependencies
+    console.log('📦 Installing dependencies...');
+    try {
+      execSync('bun install', { stdio: 'inherit', cwd: process.cwd() });
+      console.log('✅ Dependencies installed');
+    } catch (error) {
+      console.error('❌ Failed to install dependencies:', error);
+      await this.rollback(backup);
+      throw error;
+    }
+    
+    // Rebuild
+    console.log('🔨 Rebuilding BS9...');
+    try {
+      execSync('bun run build', { stdio: 'inherit', cwd: process.cwd() });
+      console.log('✅ Build completed');
+    } catch (error) {
+      console.error('❌ Build failed:', error);
+      await this.rollback(backup);
+      throw error;
+    }
+    
+    // Save backup info
+    const backupInfoPath = join(this.backupDir, `current-backup.json`);
+    writeFileSync(backupInfoPath, JSON.stringify(backup, null, 2));
+    
+    console.log('🎉 BS9 updated successfully!');
+    console.log(`   Version: ${packageJson.version}`);
+    console.log(`   Backup: ${backup.version}-${backup.timestamp}`);
+  }
+  
+  public async rollback(backup?: BackupInfo): Promise<void> {
+    console.log('🔄 Rolling back BS9...');
+    
+    let backupInfo: BackupInfo;
+    if (backup) {
+      backupInfo = backup;
+    } else {
+      // Load latest backup
+      const backupInfoPath = join(this.backupDir, 'current-backup.json');
+      if (!existsSync(backupInfoPath)) {
+        console.error('❌ No backup found for rollback');
+        return;
+      }
+      backupInfo = JSON.parse(require('fs').readFileSync(backupInfoPath, 'utf-8'));
+    }
+    
+    const backupPath = join(this.backupDir, `backup-${backupInfo.version}-${backupInfo.timestamp}`);
+    
+    if (!existsSync(backupPath)) {
+      console.error(`❌ Backup not found: ${backupPath}`);
+      return;
+    }
+    
+    // Restore files
+    for (const file of backupInfo.files) {
+      const sourcePath = join(backupPath, file);
+      const targetPath = join(process.cwd(), file);
+      
+      try {
+        execSync(`cp -r "${sourcePath}" "${targetPath}"`, { stdio: 'ignore' });
+        console.log(`✅ Restored ${file}`);
+      } catch (error) {
+        console.warn(`⚠️  Failed to restore ${file}: ${error}`);
+      }
+    }
+    
+    // Reinstall dependencies
+    console.log('📦 Reinstalling dependencies...');
+    try {
+      execSync('bun install', { stdio: 'inherit', cwd: process.cwd() });
+      console.log('✅ Dependencies reinstalled');
+    } catch (error) {
+      console.error('❌ Failed to reinstall dependencies:', error);
+    }
+    
+    console.log(`🔄 Rollback to version ${backupInfo.version} completed`);
+  }
+  
+  private listBackups(): void {
+    console.log('📋 BS9 Backup History:');
+    console.log('='.repeat(50));
+    
+    try {
+      const backups = execSync(`ls -la "${this.backupDir}" | grep backup-`, { encoding: 'utf-8' });
+      const lines = backups.trim().split('\n');
+      
+      if (lines.length === 0) {
+        console.log('No backups found.');
+        return;
+      }
+      
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        const backupName = parts[parts.length - 1];
+        const match = backupName.match(/backup-(.+)-(\d+)/);
+        
+        if (match) {
+          const [, version, timestamp] = match;
+          const date = new Date(parseInt(timestamp));
+          console.log(`${version.padEnd(10)} ${date.toISOString()} ${backupName}`);
+        }
+      }
+    } catch (error) {
+      console.error('❌ Failed to list backups:', error);
+    }
+  }
+  
+  public async checkForUpdates(options?: { check?: boolean; force?: boolean }): Promise<void> {
+    console.log('🔍 Checking for BS9 updates...');
+    const updateInfo = await this.getUpdateInfo();
+    
+    console.log(`Current version: ${updateInfo.currentVersion}`);
+    console.log(`Latest version:  ${updateInfo.latestVersion}`);
+    
+    if (!options?.force && !updateInfo.hasUpdate) {
+      console.log('✅ BS9 is up to date');
+      console.log(`   Current version: ${updateInfo.currentVersion}`);
+      return;
+    }
+    
+    if (updateInfo.hasUpdate) {
+      console.log('✨ Update available!');
+      console.log(`   Run: bs9 update to install ${updateInfo.latestVersion}`);
+    } else {
+      console.log('✅ BS9 is up to date');
+      console.log(`   Current version: ${updateInfo.currentVersion}`);
+    }
+  }
+}
+
+export async function updateCommand(options: UpdateOptions): Promise<void> {
+  const updater = new BS9Updater();
+
+  try {
+    if (options.check) {
+      await updater.checkForUpdates(options);
+      return;
+    }
+    
+    if (options.rollback) {
+      await updater.rollback();
+      return;
+    }
+    
+    // Check for updates first
+    const updateInfo = await updater.getUpdateInfo();
+    
+    if (!options.force && !updateInfo.hasUpdate) {
+      console.log('✅ BS9 is already up to date');
+      console.log(`   Current version: ${updateInfo.currentVersion}`);
+      return;
+    }
+    
+    if (updateInfo.hasUpdate) {
+      console.log(`📦 Update available: ${updateInfo.currentVersion} → ${updateInfo.latestVersion}`);
+    }
+    
+    // Perform update
+    await updater.performUpdate(options.version);
+    
+  } catch (error) {
+    console.error('❌ Update failed:', error);
+    process.exit(1);
+  }
+}

package/src/discovery/consul.ts

@@ -0,0 +1,285 @@
+#!/usr/bin/env bun
+
+import { execSync } from "node:child_process";
+
+interface ConsulService {
+  ID: string;
+  Name: string;
+  Tags: string[];
+  Address: string;
+  Port: number;
+  EnableTagOverride: boolean;
+  Meta: Record<string, string>;
+}
+
+interface ConsulHealthCheck {
+  HTTP?: string;
+  TCP?: string;
+  Interval: string;
+  Timeout: string;
+  DeregisterCriticalServiceAfter: string;
+}
+
+interface ConsulRegistration {
+  Name: string;
+  ID: string;
+  Tags: string[];
+  Address: string;
+  Port: number;
+  EnableTagOverride: boolean;
+  Check: ConsulHealthCheck;
+  Meta?: Record<string, string>;
+}
+
+class ConsulServiceDiscovery {
+  private consulUrl: string;
+  private serviceName: string = '';
+  private serviceId: string = '';
+  private registeredServices: Map<string, ConsulService> = new Map();
+  
+  constructor(consulUrl: string = 'http://localhost:8500') {
+    this.consulUrl = consulUrl;
+  }
+  
+  async registerService(config: {
+    name: string;
+    id: string;
+    address: string;
+    port: number;
+    tags?: string[];
+    healthCheck?: string;
+    meta?: Record<string, string>;
+  }): Promise<void> {
+    const registration: ConsulRegistration = {
+      Name: config.name,
+      ID: config.id,
+      Tags: config.tags || ['bs9', 'service'],
+      Address: config.address,
+      Port: config.port,
+      EnableTagOverride: false,
+      Check: {
+        HTTP: config.healthCheck || `http://${config.address}:${config.port}/healthz`,
+        Interval: '10s',
+        Timeout: '5s',
+        DeregisterCriticalServiceAfter: '30s'
+      },
+      Meta: config.meta || {}
+    };
+    
+    try {
+      const response = await fetch(`${this.consulUrl}/v1/agent/service/register`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(registration)
+      });
+      
+      if (response.ok) {
+        console.log(`✅ Service ${config.name} registered with Consul`);
+        this.registeredServices.set(config.id, {
+          ID: config.id,
+          Name: config.name,
+          Tags: registration.Tags,
+          Address: config.address,
+          Port: config.port,
+          EnableTagOverride: registration.EnableTagOverride,
+          Meta: registration.Meta || {}
+        });
+      } else {
+        throw new Error(`Failed to register service: ${response.statusText}`);
+      }
+    } catch (error) {
+      console.error(`❌ Consul registration failed: ${error}`);
+      throw error;
+    }
+  }
+  
+  async deregisterService(serviceId: string): Promise<void> {
+    try {
+      const response = await fetch(`${this.consulUrl}/v1/agent/service/deregister/${serviceId}`, {
+        method: 'PUT'
+      });
+      
+      if (response.ok) {
+        console.log(`✅ Service ${serviceId} deregistered from Consul`);
+        this.registeredServices.delete(serviceId);
+      } else {
+        throw new Error(`Failed to deregister service: ${response.statusText}`);
+      }
+    } catch (error) {
+      console.error(`❌ Consul deregistration failed: ${error}`);
+      throw error;
+    }
+  }
+  
+  async discoverServices(serviceName?: string): Promise<ConsulService[]> {
+    try {
+      let url = `${this.consulUrl}/v1/agent/services`;
+      if (serviceName) {
+        url += `?service=${serviceName}`;
+      }
+      
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to discover services: ${response.statusText}`);
+      }
+      
+      const services: Record<string, ConsulService> = await response.json();
+      return Object.values(services).filter(service => 
+        service.Tags.includes('bs9')
+      );
+    } catch (error) {
+      console.error(`❌ Service discovery failed: ${error}`);
+      return [];
+    }
+  }
+  
+  async getServiceHealth(serviceName: string): Promise<any[]> {
+    try {
+      const response = await fetch(`${this.consulUrl}/v1/health/service/${serviceName}`);
+      if (!response.ok) {
+        throw new Error(`Failed to get service health: ${response.statusText}`);
+      }
+      
+      return await response.json();
+    } catch (error) {
+      console.error(`❌ Health check failed: ${error}`);
+      return [];
+    }
+  }
+  
+  async watchService(serviceName: string, callback: (services: ConsulService[]) => void): Promise<void> {
+    let lastServices: ConsulService[] = [];
+    
+    const checkServices = async () => {
+      try {
+        const services = await this.discoverServices(serviceName);
+        
+        // Check if services have changed
+        const servicesChanged = JSON.stringify(services) !== JSON.stringify(lastServices);
+        
+        if (servicesChanged) {
+          callback(services);
+          lastServices = services;
+        }
+      } catch (error) {
+        console.error(`❌ Service watch error: ${error}`);
+      }
+    };
+    
+    // Initial check
+    await checkServices();
+    
+    // Set up periodic checking
+    setInterval(checkServices, 5000);
+  }
+  
+  getRegisteredServices(): ConsulService[] {
+    return Array.from(this.registeredServices.values());
+  }
+  
+  async isConsulAvailable(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.consulUrl}/v1/status/leader`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export async function consulCommand(action: string, options: any): Promise<void> {
+  const consul = new ConsulServiceDiscovery(options.consulUrl);
+  
+  try {
+    switch (action) {
+      case 'register':
+        if (!options.name || !options.id || !options.address || !options.port) {
+          console.error('❌ --name, --id, --address, and --port are required for register');
+          process.exit(1);
+        }
+        
+        await consul.registerService({
+          name: options.name,
+          id: options.id,
+          address: options.address,
+          port: parseInt(options.port),
+          tags: options.tags ? options.tags.split(',') : undefined,
+          healthCheck: options.healthCheck,
+          meta: options.meta ? JSON.parse(options.meta) : undefined
+        });
+        break;
+        
+      case 'deregister':
+        if (!options.id) {
+          console.error('❌ --id is required for deregister');
+          process.exit(1);
+        }
+        await consul.deregisterService(options.id);
+        break;
+        
+      case 'discover':
+        const services = await consul.discoverServices(options.service);
+        console.log('🔍 Discovered Services:');
+        console.log('='.repeat(50));
+        
+        if (services.length === 0) {
+          console.log('No BS9 services found in Consul');
+        } else {
+          services.forEach(service => {
+            console.log(`📦 ${service.Name} (${service.ID})`);
+            console.log(`   Address: ${service.Address}:${service.Port}`);
+            console.log(`   Tags: ${service.Tags.join(', ')}`);
+            console.log(`   Health: ${service.Meta?.health || 'unknown'}`);
+            console.log('');
+          });
+        }
+        break;
+        
+      case 'health':
+        if (!options.service) {
+          console.error('❌ --service is required for health check');
+          process.exit(1);
+        }
+        
+        const health = await consul.getServiceHealth(options.service);
+        console.log(`🏥 Health Status for ${options.service}:`);
+        console.log('='.repeat(50));
+        
+        if (health.length === 0) {
+          console.log('No health information available');
+        } else {
+          health.forEach(check => {
+            const status = check.Checks?.[0]?.Status || 'unknown';
+            const output = check.Checks?.[0]?.Output || 'No output';
+            
+            console.log(`📦 ${check.Service.ID}`);
+            console.log(`   Status: ${status}`);
+            console.log(`   Node: ${check.Node.Node}`);
+            console.log(`   Address: ${check.Service.Address}:${check.Service.Port}`);
+            console.log(`   Output: ${output}`);
+            console.log('');
+          });
+        }
+        break;
+        
+      case 'status':
+        const available = await consul.isConsulAvailable();
+        if (available) {
+          console.log('✅ Consul is available');
+          console.log(`   URL: ${options.consulUrl || 'http://localhost:8500'}`);
+        } else {
+          console.log('❌ Consul is not available');
+          console.log(`   URL: ${options.consulUrl || 'http://localhost:8500'}`);
+        }
+        break;
+        
+      default:
+        console.error(`❌ Unknown action: ${action}`);
+        console.log('Available actions: register, deregister, discover, health, status');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`❌ Consul command failed: ${error}`);
+    process.exit(1);
+  }
+}

package/src/monitoring/advanced.ts

@@ -0,0 +1,341 @@
+#!/usr/bin/env bun
+
+import { serve } from "bun";
+import { randomBytes } from "node:crypto";
+
+interface AdvancedWidget {
+  id: string;
+  type: 'metric' | 'chart' | 'alert' | 'custom';
+  title: string;
+  config: Record<string, any>;
+  position: { x: number; y: number; width: number; height: number };
+}
+
+interface AnomalyDetection {
+  service: string;
+  metric: string;
+  baseline: number;
+  threshold: number;
+  detected: boolean;
+  timestamp: number;
+}
+
+interface AlertCorrelation {
+  id: string;
+  alerts: Array<{
+    service: string;
+    type: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    timestamp: number;
+  }>;
+  correlation: number;
+  rootCause?: string;
+}
+
+class AdvancedMonitoring {
+  private widgets: Map<string, AdvancedWidget> = new Map();
+  private anomalies: Map<string, AnomalyDetection> = new Map();
+  private correlations: Map<string, AlertCorrelation> = new Map();
+  private baselines: Map<string, number> = new Map();
+  
+  constructor() {
+    this.initializeDefaultWidgets();
+  }
+  
+  private initializeDefaultWidgets(): void {
+    // CPU Usage Widget
+    this.widgets.set('cpu-usage', {
+      id: 'cpu-usage',
+      type: 'metric',
+      title: 'CPU Usage',
+      config: {
+        metric: 'cpu',
+        unit: '%',
+        threshold: 80,
+        refreshInterval: 5000
+      },
+      position: { x: 0, y: 0, width: 300, height: 200 }
+    });
+    
+    // Memory Usage Widget
+    this.widgets.set('memory-usage', {
+      id: 'memory-usage',
+      type: 'metric',
+      title: 'Memory Usage',
+      config: {
+        metric: 'memory',
+        unit: 'MB',
+        threshold: 90,
+        refreshInterval: 5000
+      },
+      position: { x: 320, y: 0, width: 300, height: 200 }
+    });
+    
+    // Service Health Chart
+    this.widgets.set('service-health', {
+      id: 'service-health',
+      type: 'chart',
+      title: 'Service Health',
+      config: {
+        chartType: 'line',
+        timeRange: '1h',
+        metrics: ['cpu', 'memory', 'response_time'],
+        refreshInterval: 10000
+      },
+      position: { x: 0, y: 220, width: 620, height: 300 }
+    });
+    
+    // Alert Status Widget
+    this.widgets.set('alert-status', {
+      id: 'alert-status',
+      type: 'alert',
+      title: 'Active Alerts',
+      config: {
+        severity: ['high', 'critical'],
+        refreshInterval: 3000
+      },
+      position: { x: 640, y: 0, width: 300, height: 200 }
+    });
+  }
+  
+  addWidget(widget: AdvancedWidget): void {
+    this.widgets.set(widget.id, widget);
+  }
+  
+  removeWidget(widgetId: string): void {
+    this.widgets.delete(widgetId);
+  }
+  
+  updateWidget(widgetId: string, updates: Partial<AdvancedWidget>): void {
+    const widget = this.widgets.get(widgetId);
+    if (widget) {
+      Object.assign(widget, updates);
+    }
+  }
+  
+  getWidgets(): AdvancedWidget[] {
+    return Array.from(this.widgets.values());
+  }
+  
+  async detectAnomalies(serviceMetrics: Record<string, any>): Promise<AnomalyDetection[]> {
+    const anomalies: AnomalyDetection[] = [];
+    
+    for (const [serviceName, metrics] of Object.entries(serviceMetrics)) {
+      for (const [metricName, value] of Object.entries(metrics)) {
+        const key = `${serviceName}-${metricName}`;
+        const baseline = this.baselines.get(key) || 0;
+        
+        // Simple anomaly detection using statistical deviation
+        const deviation = Math.abs((value as number) - baseline) / baseline;
+        const threshold = 0.3; // 30% deviation threshold
+        
+        if (deviation > threshold) {
+          const anomaly: AnomalyDetection = {
+            service: serviceName,
+            metric: metricName,
+            baseline,
+            threshold: baseline * (1 + threshold),
+            detected: true,
+            timestamp: Date.now()
+          };
+          
+          anomalies.push(anomaly);
+          this.anomalies.set(key, anomaly);
+        }
+      }
+    }
+    
+    return anomalies;
+  }
+  
+  async correlateAlerts(alerts: Array<any>): Promise<AlertCorrelation[]> {
+    const correlations: AlertCorrelation[] = [];
+    
+    // Simple correlation based on time proximity and service relationships
+    for (let i = 0; i < alerts.length; i++) {
+      for (let j = i + 1; j < alerts.length; j++) {
+        const alert1 = alerts[i];
+        const alert2 = alerts[j];
+        
+        const timeDiff = Math.abs(alert1.timestamp - alert2.timestamp);
+        const timeThreshold = 60000; // 1 minute
+        
+        if (timeDiff < timeThreshold) {
+          const correlation: AlertCorrelation = {
+            id: randomBytes(8).toString('hex'),
+            alerts: [alert1, alert2],
+            correlation: 1 - (timeDiff / timeThreshold)
+          };
+          
+          correlations.push(correlation);
+          this.correlations.set(correlation.id, correlation);
+        }
+      }
+    }
+    
+    return correlations;
+  }
+  
+  updateBaseline(service: string, metric: string, value: number): void {
+    const key = `${service}-${metric}`;
+    const currentBaseline = this.baselines.get(key) || 0;
+    
+    // Exponential moving average for baseline
+    const alpha = 0.1;
+    const newBaseline = alpha * (value as number) + (1 - alpha) * currentBaseline;
+    
+    this.baselines.set(key, newBaseline);
+  }
+  
+  getAnomalies(): AnomalyDetection[] {
+    return Array.from(this.anomalies.values());
+  }
+  
+  getCorrelations(): AlertCorrelation[] {
+    return Array.from(this.correlations.values());
+  }
+  
+  generateDashboard(): string {
+    const widgets = this.getWidgets();
+    
+    return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>BS9 Advanced Monitoring Dashboard</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
+        .dashboard { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; max-width: 1400px; margin: 0 auto; }
+        .widget { background: white; border-radius: 8px; padding: 20px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        .widget-header { font-size: 18px; font-weight: 600; margin-bottom: 15px; color: #333; }
+        .widget-content { min-height: 150px; }
+        .metric-value { font-size: 36px; font-weight: bold; color: #007bff; }
+        .metric-unit { font-size: 14px; color: #666; margin-left: 5px; }
+        .alert-item { padding: 10px; margin: 5px 0; border-left: 4px solid #dc3545; background: #f8d7da; }
+        .anomaly-item { padding: 10px; margin: 5px 0; border-left: 4px solid #ffc107; background: #fff3cd; }
+        .chart-container { height: 200px; background: #f8f9fa; border-radius: 4px; display: flex; align-items: center; justify-content: center; }
+    </style>
+</head>
+<body>
+    <h1>🔍 BS9 Advanced Monitoring Dashboard</h1>
+    
+    <div class="dashboard">
+        ${widgets.map(widget => this.renderWidget(widget)).join('')}
+    </div>
+    
+    <script>
+        // Auto-refresh widgets
+        setInterval(() => {
+            fetch('/api/advanced-metrics')
+                .then(response => response.json())
+                .then(data => {
+                    updateWidgets(data);
+                })
+                .catch(error => console.error('Failed to fetch metrics:', error));
+        }, 5000);
+        
+        function updateWidgets(data) {
+            // Update widget content based on data
+            console.log('Updating widgets with data:', data);
+        }
+    </script>
+</body>
+</html>`;
+  }
+  
+  private renderWidget(widget: AdvancedWidget): string {
+    switch (widget.type) {
+      case 'metric':
+        return `
+          <div class="widget" style="grid-column: span ${Math.ceil(widget.position.width / 300)};">
+            <div class="widget-header">${widget.title}</div>
+            <div class="widget-content">
+              <div class="metric-value" id="${widget.id}-value">${typeof widget.config.value === 'number' ? widget.config.value : '--'}</div>
+              <span class="metric-unit">${widget.config.unit}</span>
+            </div>
+          </div>
+        `;
+      
+      case 'chart':
+        return `
+          <div class="widget" style="grid-column: span ${Math.ceil(widget.position.width / 300)};">
+            <div class="widget-header">${widget.title}</div>
+            <div class="widget-content">
+              <div class="chart-container">
+                📊 ${widget.config.chartType.toUpperCase()} Chart
+              </div>
+            </div>
+          </div>
+        `;
+      
+      case 'alert':
+        return `
+          <div class="widget" style="grid-column: span ${Math.ceil(widget.position.width / 300)};">
+            <div class="widget-header">${widget.title}</div>
+            <div class="widget-content" id="${widget.id}-alerts">
+              <div class="alert-item">No active alerts</div>
+            </div>
+          </div>
+        `;
+      
+      default:
+        return `
+          <div class="widget">
+            <div class="widget-header">${widget.title}</div>
+            <div class="widget-content">
+              Custom widget content
+            </div>
+          </div>
+        `;
+    }
+  }
+}
+
+export async function advancedMonitoringCommand(options: any): Promise<void> {
+  const monitoring = new AdvancedMonitoring();
+  
+  console.log('🔍 Starting Advanced Monitoring Dashboard...');
+  console.log('📊 Features:');
+  console.log('   - Custom widgets');
+  console.log('   - Anomaly detection');
+  console.log('   - Alert correlation');
+  console.log('   - Performance baselines');
+  
+  const server = serve({
+    port: options.port || 8090,
+    async fetch(req) {
+      const url = new URL(req.url);
+      
+      if (url.pathname === '/') {
+        return new Response(monitoring.generateDashboard(), {
+          headers: { 'Content-Type': 'text/html' }
+        });
+      }
+      
+      if (url.pathname === '/api/advanced-metrics') {
+        // Mock advanced metrics data
+        const metrics = {
+          widgets: monitoring.getWidgets(),
+          anomalies: monitoring.getAnomalies(),
+          correlations: monitoring.getCorrelations(),
+          timestamp: Date.now()
+        };
+        
+        return new Response(JSON.stringify(metrics), {
+          headers: { 'Content-Type': 'application/json' }
+        });
+      }
+      
+      return new Response('Not Found', { status: 404 });
+    }
+  });
+  
+  console.log(`✅ Advanced monitoring dashboard started on http://localhost:${options.port || 8090}`);
+  console.log('🔗 Features available:');
+  console.log('   - Real-time anomaly detection');
+  console.log('   - Alert correlation analysis');
+  console.log('   - Custom widget configuration');
+  console.log('   - Performance baseline tracking');
+}