bs9 1.0.0

package/src/k8s/bs9-deployment.yaml

@@ -0,0 +1,197 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: bs9-system
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: bs9-config
+  namespace: bs9-system
+data:
+  config.toml: |
+    [default]
+    port = 3000
+    otel_enabled = true
+    prometheus_enabled = true
+    environment = "production"
+
+    [security]
+    security_audit = true
+    block_eval = true
+    block_child_process_exec = true
+    block_fs_access = true
+
+    [monitoring]
+    refresh_interval = 2
+    health_check_timeout = 1000
+
+    [logging]
+    level = "info"
+    structured = true
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: bs9-manager
+  namespace: bs9-system
+  labels:
+    app: bs9-manager
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: bs9-manager
+  template:
+    metadata:
+      labels:
+        app: bs9-manager
+    spec:
+      containers:
+      - name: bs9-manager
+        image: bs9:latest
+        imagePullPolicy: IfNotPresent
+        ports:
+        - containerPort: 8080
+          name: web-dashboard
+        - containerPort: 3000
+          name: app-port
+        env:
+        - name: NODE_ENV
+          value: "production"
+        - name: WEB_DASHBOARD_PORT
+          value: "8080"
+        volumeMounts:
+        - name: config-volume
+          mountPath: /app/.config/bs9
+        - name: apps-volume
+          mountPath: /app/examples
+        resources:
+          requests:
+            memory: "128Mi"
+            cpu: "100m"
+          limits:
+            memory: "512Mi"
+            cpu: "500m"
+        livenessProbe:
+          httpGet:
+            path: /
+            port: 8080
+          initialDelaySeconds: 30
+          periodSeconds: 10
+        readinessProbe:
+          httpGet:
+            path: /
+            port: 8080
+          initialDelaySeconds: 5
+          periodSeconds: 5
+        securityContext:
+          runAsNonRoot: true
+          runAsUser: 1000
+          allowPrivilegeEscalation: false
+          readOnlyRootFilesystem: true
+          capabilities:
+            drop:
+            - ALL
+      volumes:
+      - name: config-volume
+        configMap:
+          name: bs9-config
+      - name: apps-volume
+        hostPath:
+          path: /opt/bs9-apps
+          type: DirectoryOrCreate
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: bs9-manager-service
+  namespace: bs9-system
+  labels:
+    app: bs9-manager
+spec:
+  selector:
+    app: bs9-manager
+  ports:
+  - name: web-dashboard
+    port: 8080
+    targetPort: 8080
+    protocol: TCP
+  - name: app-port
+    port: 3000
+    targetPort: 3000
+    protocol: TCP
+  type: ClusterIP
+---
+apiVersion: v1
+kind: ServiceMonitor
+metadata:
+  name: bs9-monitor
+  namespace: bs9-system
+  labels:
+    app: bs9-manager
+spec:
+  selector:
+    matchLabels:
+      app: bs9-manager
+  endpoints:
+  - port: app-port
+    path: /metrics
+    interval: 30s
+---
+apiVersion: policy/v1
+kind: PodSecurityPolicy
+metadata:
+  name: bs9-psp
+  namespace: bs9-system
+spec:
+  privileged: false
+  allowPrivilegeEscalation: false
+  requiredDropCapabilities:
+    - ALL
+  volumes:
+    - 'configMap'
+    - 'emptyDir'
+    - 'projected'
+    - 'secret'
+    - 'downwardAPI'
+    - 'persistentVolumeClaim'
+  runAsUser:
+    rule: 'MustRunAsNonRoot'
+  seLinux:
+    rule: 'RunAsAny'
+  fsGroup:
+    rule: 'RunAsAny'
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: bs9-role
+  namespace: bs9-system
+rules:
+- apiGroups: [""]
+  resources: ["pods", "services", "endpoints"]
+  verbs: ["get", "list", "watch"]
+- apiGroups: ["apps"]
+  resources: ["deployments", "replicasets"]
+  verbs: ["get", "list", "watch"]
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: bs9-rolebinding
+  namespace: bs9-system
+subjects:
+- kind: ServiceAccount
+  name: bs9-account
+  namespace: bs9-system
+roleRef:
+  kind: Role
+  name: bs9-role
+  apiGroup: rbac.authorization.k8s.io
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: bs9-account
+  namespace: bs9-system

package/src/storage/metrics.ts

@@ -0,0 +1,204 @@
+#!/usr/bin/env bun
+
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+interface MetricSnapshot {
+  timestamp: number;
+  services: ServiceMetric[];
+}
+
+interface ServiceMetric {
+  name: string;
+  cpu: string;
+  memory: number; // in bytes
+  uptime: string;
+  tasks: number;
+  health: 'healthy' | 'unhealthy' | 'unknown';
+  state: string;
+}
+
+class MetricsStorage {
+  private storageDir: string;
+  private maxSnapshots: number = 1000; // Keep last 1000 snapshots
+  
+  constructor() {
+    this.storageDir = join(homedir(), ".config", "bs9", "metrics");
+    if (!existsSync(this.storageDir)) {
+      mkdirSync(this.storageDir, { recursive: true });
+    }
+  }
+  
+  storeSnapshot(services: ServiceMetric[]): void {
+    const snapshot: MetricSnapshot = {
+      timestamp: Date.now(),
+      services,
+    };
+    
+    const filename = `metrics-${snapshot.timestamp}.json`;
+    const filepath = join(this.storageDir, filename);
+    
+    try {
+      writeFileSync(filepath, JSON.stringify(snapshot, null, 2));
+      
+      // Cleanup old snapshots
+      this.cleanupOldSnapshots();
+    } catch (error) {
+      console.error('Failed to store metrics snapshot:', error);
+    }
+  }
+  
+  getHistoricalData(hours: number = 24): MetricSnapshot[] {
+    const cutoffTime = Date.now() - (hours * 60 * 60 * 1000);
+    const snapshots: MetricSnapshot[] = [];
+    
+    try {
+      const files = this.getMetricFiles();
+      
+      for (const file of files) {
+        const filepath = join(this.storageDir, file);
+        const content = readFileSync(filepath, 'utf-8');
+        const snapshot: MetricSnapshot = JSON.parse(content);
+        
+        if (snapshot.timestamp >= cutoffTime) {
+          snapshots.push(snapshot);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to read historical data:', error);
+    }
+    
+    return snapshots.sort((a, b) => a.timestamp - b.timestamp);
+  }
+  
+  getServiceMetrics(serviceName: string, hours: number = 24): ServiceMetric[] {
+    const snapshots = this.getHistoricalData(hours);
+    const metrics: ServiceMetric[] = [];
+    
+    for (const snapshot of snapshots) {
+      const serviceMetric = snapshot.services.find(s => s.name === serviceName);
+      if (serviceMetric) {
+        metrics.push(serviceMetric);
+      }
+    }
+    
+    return metrics;
+  }
+  
+  getAggregatedMetrics(hours: number = 24): {
+    avgCpu: number;
+    avgMemory: number;
+    uptime: number;
+    totalRequests: number;
+    errorRate: number;
+  } {
+    const snapshots = this.getHistoricalData(hours);
+    
+    if (snapshots.length === 0) {
+      return {
+        avgCpu: 0,
+        avgMemory: 0,
+        uptime: 0,
+        totalRequests: 0,
+        errorRate: 0,
+      };
+    }
+    
+    let totalCpu = 0;
+    let totalMemory = 0;
+    let healthyCount = 0;
+    let totalCount = 0;
+    
+    for (const snapshot of snapshots) {
+      for (const service of snapshot.services) {
+        // Parse CPU from string like "12.3ms" to number
+        const cpuMatch = service.cpu.match(/([\d.]+)ms/);
+        if (cpuMatch) {
+          totalCpu += parseFloat(cpuMatch[1]);
+        }
+        
+        totalMemory += service.memory;
+        totalCount++;
+        
+        if (service.health === 'healthy') {
+          healthyCount++;
+        }
+      }
+    }
+    
+    return {
+      avgCpu: totalCpu / (snapshots.length * Math.max(1, snapshots[0]?.services.length || 1)),
+      avgMemory: totalMemory / Math.max(1, snapshots.length * Math.max(1, snapshots[0]?.services.length || 1)),
+      uptime: (healthyCount / Math.max(1, totalCount)) * 100,
+      totalRequests: totalCount,
+      errorRate: ((totalCount - healthyCount) / Math.max(1, totalCount)) * 100,
+    };
+  }
+  
+  private getMetricFiles(): string[] {
+    try {
+      const { readdirSync } = require("node:fs");
+      const files = readdirSync(this.storageDir);
+      return files
+        .filter((file: string) => file.startsWith('metrics-') && file.endsWith('.json'))
+        .sort((a: string, b: string) => {
+          const timeA = parseInt(a.split('-')[1].split('.')[0]);
+          const timeB = parseInt(b.split('-')[1].split('.')[0]);
+          return timeB - timeA;
+        });
+    } catch (error) {
+      return [];
+    }
+  }
+  
+  private cleanupOldSnapshots(): void {
+    const files = this.getMetricFiles();
+    
+    if (files.length > this.maxSnapshots) {
+      const filesToDelete = files.slice(this.maxSnapshots);
+      
+      for (const file of filesToDelete) {
+        try {
+          const { unlinkSync } = require("node:fs");
+          unlinkSync(join(this.storageDir, file));
+        } catch (error) {
+          console.error(`Failed to delete old metrics file ${file}:`, error);
+        }
+      }
+    }
+  }
+  
+  exportData(format: 'json' | 'csv' = 'json'): string {
+    const snapshots = this.getHistoricalData(24 * 7); // Last week
+    
+    if (format === 'csv') {
+      const headers = ['timestamp', 'service_name', 'cpu_ms', 'memory_bytes', 'uptime', 'tasks', 'health', 'state'];
+      const rows = [headers.join(',')];
+      
+      for (const snapshot of snapshots) {
+        for (const service of snapshot.services) {
+          const cpuMatch = service.cpu.match(/([\d.]+)ms/);
+          const cpuMs = cpuMatch ? cpuMatch[1] : '0';
+          
+          rows.push([
+            new Date(snapshot.timestamp).toISOString(),
+            service.name,
+            cpuMs,
+            service.memory.toString(),
+            service.uptime,
+            service.tasks.toString(),
+            service.health,
+            service.state,
+          ].join(','));
+        }
+      }
+      
+      return rows.join('\n');
+    }
+    
+    return JSON.stringify(snapshots, null, 2);
+  }
+}
+
+export { MetricsStorage, ServiceMetric, MetricSnapshot };

package/src/web/dashboard.ts

@@ -0,0 +1,286 @@
+#!/usr/bin/env bun
+
+import { serve } from "bun";
+import { execSync } from "node:child_process";
+import { join } from "node:path";
+
+interface ServiceMetrics {
+  name: string;
+  loaded: string;
+  active: string;
+  sub: string;
+  state: string;
+  cpu: string;
+  memory: string;
+  uptime: string;
+  tasks: string;
+  health: string;
+  description: string;
+}
+
+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}`,
+        cpu: '-',
+        memory: '-',
+        uptime: '-',
+        tasks: '-',
+        health: 'unknown',
+        description,
+      };
+      
+      // 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+)/);
+        
+        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];
+        }
+      } 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" ? "healthy" : "unhealthy";
+        }
+      } 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 HTML_TEMPLATE = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>BS9 Web Dashboard</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #f5f5f5; }
+        .container { max-width: 1200px; margin: 0 auto; padding: 20px; }
+        .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; margin-bottom: 20px; }
+        .stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-bottom: 20px; }
+        .stat-card { background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        .stat-value { font-size: 2em; font-weight: bold; color: #333; }
+        .stat-label { color: #666; margin-top: 5px; }
+        .services-table { background: white; border-radius: 8px; overflow: hidden; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        table { width: 100%; border-collapse: collapse; }
+        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #eee; }
+        th { background: #f8f9fa; font-weight: 600; }
+        .status-healthy { color: #28a745; font-weight: bold; }
+        .status-unhealthy { color: #dc3545; font-weight: bold; }
+        .status-unknown { color: #ffc107; font-weight: bold; }
+        .state-active { color: #28a745; }
+        .state-failed { color: #dc3545; }
+        .refresh-btn { background: #007bff; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; }
+        .refresh-btn:hover { background: #0056b3; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🔍 BS9 Web Dashboard</h1>
+            <p>Real-time monitoring dashboard for BS9 services</p>
+            <button class="refresh-btn" onclick="location.reload()">Refresh</button>
+        </div>
+        
+        <div class="stats" id="stats">
+            <!-- Stats will be populated by JavaScript -->
+        </div>
+        
+        <div class="services-table">
+            <table>
+                <thead>
+                    <tr>
+                        <th>Service</th>
+                        <th>State</th>
+                        <th>Health</th>
+                        <th>CPU</th>
+                        <th>Memory</th>
+                        <th>Uptime</th>
+                        <th>Tasks</th>
+                    </tr>
+                </thead>
+                <tbody id="services-tbody">
+                    <!-- Services will be populated by JavaScript -->
+                </tbody>
+            </table>
+        </div>
+    </div>
+    
+    <script>
+        async function loadMetrics() {
+            try {
+                const response = await fetch('/api/metrics');
+                const data = await response.json();
+                
+                // Update stats
+                const statsHtml = \`
+                    <div class="stat-card">
+                        <div class="stat-value">\${data.total}</div>
+                        <div class="stat-label">Total Services</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-value">\${data.running}</div>
+                        <div class="stat-label">Running</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-value">\${data.totalMemory}</div>
+                        <div class="stat-label">Total Memory</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-value">\${data.lastUpdate}</div>
+                        <div class="stat-label">Last Update</div>
+                    </div>
+                \`;
+                document.getElementById('stats').innerHTML = statsHtml;
+                
+                // Update services table
+                const tbody = document.getElementById('services-tbody');
+                tbody.innerHTML = data.services.map(service => \`
+                    <tr>
+                        <td><strong>\${service.name}</strong></td>
+                        <td class="state-\${service.active === 'active' ? 'active' : 'failed'}">\${service.state}</td>
+                        <td class="status-\${service.health}">\${service.health.toUpperCase()}</td>
+                        <td>\${service.cpu}</td>
+                        <td>\${service.memory}</td>
+                        <td>\${service.uptime}</td>
+                        <td>\${service.tasks}</td>
+                    </tr>
+                \`).join('');
+                
+            } catch (error) {
+                console.error('Error loading metrics:', error);
+            }
+        }
+        
+        // Load metrics on page load
+        loadMetrics();
+        
+        // Auto-refresh every 5 seconds
+        setInterval(loadMetrics, 5000);
+    </script>
+</body>
+</html>
+`;
+
+serve({
+  port: process.env.WEB_DASHBOARD_PORT || 8080,
+  fetch(req) {
+    const url = new URL(req.url);
+    
+    if (url.pathname === '/api/metrics') {
+      const services = getMetrics();
+      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);
+      
+      const data = {
+        services,
+        total: services.length,
+        running,
+        totalMemory: formatMemory(totalMemory),
+        lastUpdate: new Date().toLocaleTimeString(),
+      };
+      
+      return new Response(JSON.stringify(data), {
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+    
+    if (url.pathname === '/') {
+      return new Response(HTML_TEMPLATE, {
+        headers: { 'Content-Type': 'text/html' }
+      });
+    }
+    
+    return new Response('Not Found', { status: 404 });
+  },
+});
+
+console.log(`🌐 BS9 Web Dashboard running on http://localhost:${process.env.WEB_DASHBOARD_PORT || 8080}`);