bs9 1.0.0 → 1.3.0

package/src/commands/deps.ts

@@ -0,0 +1,295 @@
+#!/usr/bin/env bun
+
+import { execSync } from "node:child_process";
+import { setTimeout } from "node:timers/promises";
+
+interface DepOptions {
+  format?: string;
+  output?: string;
+}
+
+interface ServiceDependency {
+  name: string;
+  dependsOn: string[];
+  status: 'running' | 'stopped' | 'failed' | 'unknown';
+  health: 'healthy' | 'unhealthy' | 'unknown';
+  port?: number;
+  endpoints: string[];
+}
+
+interface DependencyGraph {
+  services: ServiceDependency[];
+  edges: Array<{
+    from: string;
+    to: string;
+    type: 'http' | 'database' | 'message' | 'custom';
+  }>;
+}
+
+export async function depsCommand(options: DepOptions): Promise<void> {
+  console.log('🔗 BS9 Service Dependency Visualization');
+  console.log('='.repeat(80));
+  
+  try {
+    const graph = await buildDependencyGraph();
+    
+    if (options.format === 'dot') {
+      const dotOutput = generateDotGraph(graph);
+      if (options.output) {
+        await Bun.write(options.output, dotOutput);
+        console.log(`✅ Dependency graph saved to: ${options.output}`);
+      } else {
+        console.log(dotOutput);
+      }
+    } else if (options.format === 'json') {
+      const jsonOutput = JSON.stringify(graph, null, 2);
+      if (options.output) {
+        await Bun.write(options.output, jsonOutput);
+        console.log(`✅ Dependency graph saved to: ${options.output}`);
+      } else {
+        console.log(jsonOutput);
+      }
+    } else {
+      displayDependencyGraph(graph);
+    }
+    
+  } catch (error) {
+    console.error(`❌ Failed to analyze dependencies: ${error}`);
+    process.exit(1);
+  }
+}
+
+async function buildDependencyGraph(): Promise<DependencyGraph> {
+  const services: ServiceDependency[] = [];
+  const edges: Array<{from: string; to: string; type: 'http' | 'database' | 'message' | 'custom'}> = [];
+  
+  try {
+    // Get all BS9 services
+    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"));
+    
+    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: ServiceDependency = {
+        name,
+        dependsOn: [],
+        status: getServiceStatus(active, sub),
+        health: 'unknown',
+        endpoints: [],
+      };
+      
+      // Extract port from description
+      const portMatch = description.match(/port[=:]?\s*(\d+)/i);
+      if (portMatch) {
+        service.port = Number(portMatch[1]);
+      }
+      
+      // Analyze service for dependencies
+      const deps = await analyzeServiceDependencies(name, service.port);
+      service.dependsOn = deps.dependsOn;
+      service.endpoints = deps.endpoints;
+      
+      services.push(service);
+      
+      // Add edges to graph
+      for (const dep of deps.dependsOn) {
+        edges.push({
+          from: name,
+          to: dep,
+          type: deps.type,
+        });
+      }
+    }
+    
+  } catch (error) {
+    console.error('Error fetching services:', error);
+  }
+  
+  return { services, edges };
+}
+
+async function analyzeServiceDependencies(serviceName: string, port?: number): Promise<{
+  dependsOn: string[];
+  endpoints: string[];
+  type: 'http' | 'database' | 'message' | 'custom';
+}> {
+  const dependsOn: string[] = [];
+  const endpoints: string[] = [];
+  let type: 'http' | 'database' | 'message' | 'custom' = 'custom';
+  
+  try {
+    // Check if service has health endpoints
+    if (port) {
+      endpoints.push(`http://localhost:${port}/healthz`);
+      endpoints.push(`http://localhost:${port}/readyz`);
+      endpoints.push(`http://localhost:${port}/metrics`);
+      
+      // Check for common dependency patterns
+      try {
+        const response = Bun.fetch(`http://localhost:${port}/dependencies`, { timeout: 1000 });
+        if (response.ok) {
+          const deps = await response.json();
+          if (Array.isArray(deps)) {
+            dependsOn.push(...deps);
+            type = 'http';
+          }
+        }
+      } catch {
+        // Service doesn't expose dependencies endpoint
+      }
+    }
+    
+    // Analyze service files for dependency patterns
+    try {
+      const servicePath = `/home/xarhang/.config/systemd/user/${serviceName}.service`;
+      const serviceContent = Bun.file(servicePath).text();
+      
+      // Look for environment variables that suggest dependencies
+      const envMatches = serviceContent.match(/Environment=([^\n]+)/g) || [];
+      for (const env of envMatches) {
+        if (env.includes('DATABASE_URL') || env.includes('DB_HOST')) {
+          dependsOn.push('database');
+          type = 'database';
+        }
+        if (env.includes('REDIS_URL') || env.includes('REDIS_HOST')) {
+          dependsOn.push('redis');
+          type = 'message';
+        }
+        if (env.includes('API_URL') || env.includes('SERVICE_URL')) {
+          const urlMatch = env.match(/https?:\/\/([^:\/]+)/);
+          if (urlMatch) {
+            dependsOn.push(urlMatch[1]);
+            type = 'http';
+          }
+        }
+      }
+    } catch {
+      // Service file not accessible
+    }
+    
+  } catch (error) {
+    console.error(`Error analyzing dependencies for ${serviceName}:`, error);
+  }
+  
+  return { dependsOn, endpoints, type };
+}
+
+function getServiceStatus(active: string, sub: string): 'running' | 'stopped' | 'failed' | 'unknown' {
+  if (active === 'active' && sub === 'running') return 'running';
+  if (active === 'inactive') return 'stopped';
+  if (active === 'failed' || sub === 'failed') return 'failed';
+  return 'unknown';
+}
+
+function displayDependencyGraph(graph: DependencyGraph): void {
+  console.log('\n📊 Service Dependencies:');
+  console.log('-'.repeat(60));
+  
+  for (const service of graph.services) {
+    const statusIcon = getStatusIcon(service.status);
+    const healthIcon = getHealthIcon(service.health);
+    
+    console.log(`${statusIcon} ${service.name} ${healthIcon}`);
+    
+    if (service.dependsOn.length > 0) {
+      console.log(`   └─ Depends on: ${service.dependsOn.join(', ')}`);
+    }
+    
+    if (service.endpoints.length > 0) {
+      console.log(`   └─ Endpoints: ${service.endpoints.slice(0, 2).join(', ')}${service.endpoints.length > 2 ? '...' : ''}`);
+    }
+    
+    console.log('');
+  }
+  
+  console.log('\n🔗 Dependency Relationships:');
+  console.log('-'.repeat(60));
+  
+  if (graph.edges.length === 0) {
+    console.log('No dependencies found between services.');
+  } else {
+    for (const edge of graph.edges) {
+      const fromService = graph.services.find(s => s.name === edge.from);
+      const toService = graph.services.find(s => s.name === edge.to);
+      
+      const fromIcon = fromService ? getStatusIcon(fromService.status) : '❓';
+      const toIcon = toService ? getStatusIcon(toService.status) : '❓';
+      
+      console.log(`${fromIcon} ${edge.from} → ${edge.to} ${toIcon} (${edge.type})`);
+    }
+  }
+  
+  console.log('\n📈 Summary:');
+  console.log(`   Total Services: ${graph.services.length}`);
+  console.log(`   Dependencies: ${graph.edges.length}`);
+  console.log(`   Running: ${graph.services.filter(s => s.status === 'running').length}`);
+  console.log(`   Failed: ${graph.services.filter(s => s.status === 'failed').length}`);
+}
+
+function generateDotGraph(graph: DependencyGraph): string {
+  let dot = 'digraph BS9_Dependencies {\n';
+  dot += '  rankdir=LR;\n';
+  dot += '  node [shape=box, style=filled];\n\n';
+  
+  // Add nodes
+  for (const service of graph.services) {
+    const color = getNodeColor(service.status);
+    const label = `${service.name}\\n${service.status}`;
+    dot += `  "${service.name}" [label="${label}", fillcolor="${color}"];\n`;
+  }
+  
+  dot += '\n';
+  
+  // Add edges
+  for (const edge of graph.edges) {
+    const color = getEdgeColor(edge.type);
+    dot += `  "${edge.from}" -> "${edge.to}" [color="${color}", label="${edge.type}"];\n`;
+  }
+  
+  dot += '}\n';
+  
+  return dot;
+}
+
+function getStatusIcon(status: string): string {
+  switch (status) {
+    case 'running': return '✅';
+    case 'stopped': return '⏸️';
+    case 'failed': return '❌';
+    default: return '❓';
+  }
+}
+
+function getHealthIcon(health: string): string {
+  switch (health) {
+    case 'healthy': return '🟢';
+    case 'unhealthy': return '🔴';
+    default: return '⚪';
+  }
+}
+
+function getNodeColor(status: string): string {
+  switch (status) {
+    case 'running': return 'lightgreen';
+    case 'stopped': return 'lightgray';
+    case 'failed': return 'lightcoral';
+    default: return 'lightyellow';
+  }
+}
+
+function getEdgeColor(type: string): string {
+  switch (type) {
+    case 'http': return 'blue';
+    case 'database': return 'green';
+    case 'message': return 'orange';
+    default: return 'gray';
+  }
+}

package/src/commands/profile.ts

@@ -0,0 +1,338 @@
+#!/usr/bin/env bun
+
+import { execSync } from "node:child_process";
+import { setTimeout } from "node:timers/promises";
+
+interface ProfileOptions {
+  duration?: string;
+  output?: string;
+  service?: string;
+  interval?: string;
+}
+
+interface ProfileData {
+  timestamp: number;
+  cpu: number;
+  memory: number;
+  heapUsed: number;
+  heapTotal: number;
+  external: number;
+  eventLoopLag: number;
+  activeHandles: number;
+  activeRequests: number;
+}
+
+interface PerformanceProfile {
+  serviceName: string;
+  duration: number;
+  interval: number;
+  samples: ProfileData[];
+  summary: {
+    avgCpu: number;
+    maxCpu: number;
+    avgMemory: number;
+    maxMemory: number;
+    avgHeapUsed: number;
+    maxHeapUsed: number;
+    avgEventLoopLag: number;
+    maxEventLoopLag: number;
+  };
+}
+
+export async function profileCommand(options: ProfileOptions): Promise<void> {
+  const duration = Number(options.duration) || 60; // Default 60 seconds
+  const interval = Number(options.interval) || 1000; // Default 1 second
+  const serviceName = options.service;
+  
+  if (!serviceName) {
+    console.error('❌ Service name is required. Use --service <name>');
+    process.exit(1);
+  }
+  
+  console.log(`📊 Performance Profiling for Service: ${serviceName}`);
+  console.log(`⏱️  Duration: ${duration}s | Interval: ${interval}ms`);
+  console.log('='.repeat(80));
+  
+  try {
+    // Check if service is running
+    const serviceStatus = checkServiceStatus(serviceName);
+    if (serviceStatus !== 'active') {
+      console.error(`❌ Service '${serviceName}' is not running (status: ${serviceStatus})`);
+      process.exit(1);
+    }
+    
+    // Get service port for metrics
+    const port = getServicePort(serviceName);
+    if (!port) {
+      console.error(`❌ Could not determine port for service '${serviceName}'`);
+      process.exit(1);
+    }
+    
+    console.log(`🔍 Collecting metrics from http://localhost:${port}/metrics`);
+    console.log('Press Ctrl+C to stop profiling early\n');
+    
+    const profile = await collectPerformanceData(serviceName, port, duration, interval);
+    
+    // Display results
+    displayProfileResults(profile);
+    
+    // Save to file if requested
+    if (options.output) {
+      await saveProfileData(profile, options.output);
+      console.log(`💾 Profile data saved to: ${options.output}`);
+    }
+    
+  } catch (error) {
+    console.error(`❌ Failed to profile service: ${error}`);
+    process.exit(1);
+  }
+}
+
+function checkServiceStatus(serviceName: string): string {
+  try {
+    const output = execSync(`systemctl --user is-active ${serviceName}`, { encoding: "utf-8" }).trim();
+    return output;
+  } catch {
+    return 'unknown';
+  }
+}
+
+function getServicePort(serviceName: string): number | null {
+  try {
+    const servicePath = `/home/xarhang/.config/systemd/user/${serviceName}.service`;
+    const serviceContent = execSync(`cat ${servicePath}`, { encoding: "utf-8" });
+    
+    // Extract port from environment variables
+    const portMatch = serviceContent.match(/Environment=.*PORT=(\d+)/);
+    if (portMatch) {
+      return Number(portMatch[1]);
+    }
+    
+    // Extract port from description
+    const descMatch = serviceContent.match(/port[=:]?\s*(\d+)/i);
+    if (descMatch) {
+      return Number(descMatch[1]);
+    }
+    
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function collectPerformanceData(
+  serviceName: string,
+  port: number,
+  duration: number,
+  interval: number
+): Promise<PerformanceProfile> {
+  const samples: ProfileData[] = [];
+  const startTime = Date.now();
+  const endTime = startTime + (duration * 1000);
+  
+  while (Date.now() < endTime) {
+    try {
+      const sample = await collectSample(port);
+      samples.push(sample);
+      
+      // Show progress
+      const elapsed = Math.floor((Date.now() - startTime) / 1000);
+      const progress = Math.round((elapsed / duration) * 100);
+      process.stdout.write(`\r⏳ Progress: ${elapsed}s/${duration}s (${progress}%) | Samples: ${samples.length}`);
+      
+      await setTimeout(interval);
+    } catch (error) {
+      console.error(`\n⚠️  Failed to collect sample: ${error}`);
+      break;
+    }
+  }
+  
+  console.log('\n'); // New line after progress
+  
+  // Calculate summary
+  const summary = calculateSummary(samples);
+  
+  return {
+    serviceName,
+    duration,
+    interval,
+    samples,
+    summary,
+  };
+}
+
+async function collectSample(port: number): Promise<ProfileData> {
+  const response = await fetch(`http://localhost:${port}/metrics`);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  
+  const metricsText = await response.text();
+  const metrics = parsePrometheusMetrics(metricsText);
+  
+  return {
+    timestamp: Date.now(),
+    cpu: metrics.cpu || 0,
+    memory: metrics.memory || 0,
+    heapUsed: metrics.heapUsed || 0,
+    heapTotal: metrics.heapTotal || 0,
+    external: metrics.external || 0,
+    eventLoopLag: metrics.eventLoopLag || 0,
+    activeHandles: metrics.activeHandles || 0,
+    activeRequests: metrics.activeRequests || 0,
+  };
+}
+
+function parsePrometheusMetrics(metricsText: string): Record<string, number> {
+  const metrics: Record<string, number> = {};
+  const lines = metricsText.split('\n');
+  
+  for (const line of lines) {
+    if (line.startsWith('#') || !line.trim()) continue;
+    
+    const match = line.match(/^(.+)\s+([\d.]+)$/);
+    if (!match) continue;
+    
+    const [, name, value] = match;
+    
+    // Map Prometheus metrics to our internal names
+    switch (name) {
+      case 'process_cpu_seconds_total':
+        metrics.cpu = parseFloat(value);
+        break;
+      case 'process_resident_memory_bytes':
+        metrics.memory = parseFloat(value);
+        break;
+      case 'nodejs_heap_size_used_bytes':
+        metrics.heapUsed = parseFloat(value);
+        break;
+      case 'nodejs_heap_size_total_bytes':
+        metrics.heapTotal = parseFloat(value);
+        break;
+      case 'nodejs_external_memory_bytes':
+        metrics.external = parseFloat(value);
+        break;
+      case 'nodejs_eventloop_lag_seconds':
+        metrics.eventLoopLag = parseFloat(value) * 1000; // Convert to ms
+        break;
+      case 'nodejs_active_handles_total':
+        metrics.activeHandles = parseFloat(value);
+        break;
+      case 'nodejs_active_requests_total':
+        metrics.activeRequests = parseFloat(value);
+        break;
+    }
+  }
+  
+  return metrics;
+}
+
+function calculateSummary(samples: ProfileData[]): PerformanceProfile['summary'] {
+  if (samples.length === 0) {
+    return {
+      avgCpu: 0, maxCpu: 0,
+      avgMemory: 0, maxMemory: 0,
+      avgHeapUsed: 0, maxHeapUsed: 0,
+      avgEventLoopLag: 0, maxEventLoopLag: 0,
+    };
+  }
+  
+  const sum = samples.reduce((acc, sample) => ({
+    cpu: acc.cpu + sample.cpu,
+    memory: acc.memory + sample.memory,
+    heapUsed: acc.heapUsed + sample.heapUsed,
+    eventLoopLag: acc.eventLoopLag + sample.eventLoopLag,
+  }), { cpu: 0, memory: 0, heapUsed: 0, eventLoopLag: 0 });
+  
+  const count = samples.length;
+  
+  return {
+    avgCpu: sum.cpu / count,
+    maxCpu: Math.max(...samples.map(s => s.cpu)),
+    avgMemory: sum.memory / count,
+    maxMemory: Math.max(...samples.map(s => s.memory)),
+    avgHeapUsed: sum.heapUsed / count,
+    maxHeapUsed: Math.max(...samples.map(s => s.heapUsed)),
+    avgEventLoopLag: sum.eventLoopLag / count,
+    maxEventLoopLag: Math.max(...samples.map(s => s.eventLoopLag)),
+  };
+}
+
+function displayProfileResults(profile: PerformanceProfile): void {
+  console.log('\n📊 Performance Profile Results');
+  console.log('='.repeat(80));
+  
+  console.log(`\n🔧 Service: ${profile.serviceName}`);
+  console.log(`⏱️  Duration: ${profile.duration}s | Samples: ${profile.samples.length}`);
+  console.log(`📏 Interval: ${profile.interval}ms`);
+  
+  console.log('\n💾 Memory Usage:');
+  console.log(`   Average: ${formatBytes(profile.summary.avgMemory)} | Peak: ${formatBytes(profile.summary.maxMemory)}`);
+  console.log(`   Heap Avg: ${formatBytes(profile.summary.avgHeapUsed)} | Heap Peak: ${formatBytes(profile.summary.maxHeapUsed)}`);
+  console.log(`   External: ${formatBytes(profile.samples[0]?.external || 0)}`);
+  
+  console.log('\n⚡ Performance:');
+  console.log(`   CPU Avg: ${profile.summary.avgCpu.toFixed(2)}s | Peak: ${profile.summary.maxCpu.toFixed(2)}s`);
+  console.log(`   Event Loop Avg: ${profile.summary.avgEventLoopLag.toFixed(2)}ms | Peak: ${profile.summary.maxEventLoopLag.toFixed(2)}ms`);
+  
+  console.log('\n🔗 Resources:');
+  const lastSample = profile.samples[profile.samples.length - 1];
+  if (lastSample) {
+    console.log(`   Active Handles: ${lastSample.activeHandles} | Active Requests: ${lastSample.activeRequests}`);
+  }
+  
+  // Performance recommendations
+  console.log('\n💡 Performance Insights:');
+  
+  if (profile.summary.maxMemory > 500 * 1024 * 1024) { // > 500MB
+    console.log('   ⚠️  High memory usage detected - consider memory optimization');
+  }
+  
+  if (profile.summary.maxEventLoopLag > 100) { // > 100ms
+    console.log('   ⚠️  High event loop lag detected - consider optimizing async operations');
+  }
+  
+  if (profile.samples.length > 0) {
+    const firstSample = profile.samples[0];
+    if (firstSample.heapTotal > 0 && profile.summary.avgHeapUsed / firstSample.heapTotal > 0.8) { // > 80%
+      console.log('   ⚠️  High heap usage ratio - potential memory leak');
+    }
+  }
+  
+  if (profile.samples.length < profile.duration * 1000 / profile.interval * 0.9) {
+    console.log('   ⚠️  Some samples failed to collect - check service health');
+  }
+  
+  console.log('\n📈 Sample Timeline (last 10 samples):');
+  const recentSamples = profile.samples.slice(-10);
+  for (let i = 0; i < recentSamples.length; i++) {
+    const sample = recentSamples[i];
+    const time = new Date(sample.timestamp).toLocaleTimeString();
+    console.log(`   ${time} | CPU: ${sample.cpu.toFixed(2)}s | Memory: ${formatBytes(sample.memory)} | Heap: ${formatBytes(sample.heapUsed)}`);
+  }
+}
+
+function formatBytes(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]}`;
+}
+
+async function saveProfileData(profile: PerformanceProfile, filename: string): Promise<void> {
+  const data = {
+    metadata: {
+      serviceName: profile.serviceName,
+      duration: profile.duration,
+      interval: profile.interval,
+      sampleCount: profile.samples.length,
+      timestamp: new Date().toISOString(),
+    },
+    summary: profile.summary,
+    samples: profile.samples,
+  };
+  
+  const json = JSON.stringify(data, null, 2);
+  await Bun.write(filename, json);
+}

package/src/commands/restart.ts

@@ -1,13 +1,38 @@
 #!/usr/bin/env bun
 
 import { execSync } from "node:child_process";
+import { getPlatformInfo } from "../platform/detect.js";
+
+// Security: Service name validation
+function isValidServiceName(name: string): boolean {
+  const validPattern = /^[a-zA-Z0-9._-]+$/;
+  return validPattern.test(name) && name.length <= 64 && !name.includes('..') && !name.includes('/');
+}
 
 export async function restartCommand(name: string): Promise<void> {
+  // Security: Validate service name
+  if (!isValidServiceName(name)) {
+    console.error(`❌ Security: Invalid service name: ${name}`);
+    process.exit(1);
+  }
+  
+  const platformInfo = getPlatformInfo();
+  
   try {
-    execSync(`systemctl --user restart ${name}`, { stdio: "inherit" });
-    console.log(`🔄 User service '${name}' restarted`);
+    if (platformInfo.isLinux) {
+      // Security: Use shell escaping to prevent injection
+      const escapedName = name.replace(/[^a-zA-Z0-9._-]/g, '');
+      execSync(`systemctl --user restart "${escapedName}"`, { stdio: "inherit" });
+      console.log(`🔄 User service '${name}' restarted`);
+    } else if (platformInfo.isMacOS) {
+      const { launchdCommand } = await import("../macos/launchd.js");
+      await launchdCommand('restart', { name: `bs9.${name}` });
+    } else if (platformInfo.isWindows) {
+      const { windowsCommand } = await import("../windows/service.js");
+      await windowsCommand('restart', { name: `BS9_${name}` });
+    }
   } catch (err) {
-    console.error(`❌ Failed to restart user service '${name}': ${err}`);
+    console.error(`❌ Failed to restart service '${name}': ${err}`);
     process.exit(1);
   }
 }