bs9 1.0.0 → 1.1.0

package/src/commands/status.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 
 import { execSync } from "node:child_process";
+import { getPlatformInfo } from "../platform/detect.js";
 import { readFileSync } from "node:fs";
 
 interface StatusOptions {
@@ -20,108 +21,140 @@ interface ServiceStatus {
 }
 
 export async function statusCommand(options: StatusOptions): Promise<void> {
-  const doStatus = () => {
-    try {
-      // Get all bsn-managed user 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"));
-      
-      // Debug: show all lines
-      // console.error("All service lines:", lines);
-      
-      const services: ServiceStatus[] = [];
-      
-      for (const line of lines) {
-        // Skip empty lines
-        if (!line.trim()) continue;
-        
-        // Try to match the line format - handle both ● and regular spaces
-        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;
-        
-        // Only include services that look like BSN-managed (check for "Bun Service:" pattern)
-        if (!description.includes("Bun Service:") && !description.includes("BS9 Service:")) {
-          continue;
-        }
-        
-        const status: ServiceStatus = {
-          name,
-          loaded,
-          active,
-          sub,
-          description,
-        };
+  const platformInfo = getPlatformInfo();
+  
+  try {
+    let services: ServiceStatus[] = [];
+    
+    if (platformInfo.isLinux) {
+      services = await getLinuxServices();
+    } else if (platformInfo.isMacOS) {
+      services = await getMacOSServices();
+    } else if (platformInfo.isWindows) {
+      services = await getWindowsServices();
+    }
+    
+    displayServices(services);
+    
+    if (options.watch) {
+      console.log("\n🔄 Watching for changes (Ctrl+C to stop)...");
+      setInterval(async () => {
+        console.clear();
+        console.log("🔍 BS9 Service Status");
+        console.log("=".repeat(80));
         
-        // Get additional metrics
-        try {
-          const showOutput = execSync(`systemctl --user show ${name} -p CPUUsageNSec MemoryCurrent ActiveEnterTimestamp TasksCurrent`, { 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) status.cpu = formatCPU(Number(cpuMatch[1]));
-          if (memMatch) status.memory = formatMemory(Number(memMatch[1]));
-          if (timeMatch) status.uptime = formatUptime(timeMatch[1]);
-          if (tasksMatch) status.tasks = tasksMatch[1];
-        } catch {
-          // Ignore metrics errors
+        let updatedServices: ServiceStatus[] = [];
+        if (platformInfo.isLinux) {
+          updatedServices = await getLinuxServices();
+        } else if (platformInfo.isMacOS) {
+          updatedServices = await getMacOSServices();
+        } else if (platformInfo.isWindows) {
+          updatedServices = await getWindowsServices();
         }
         
-        services.push(status);
-      }
+        displayServices(updatedServices);
+      }, 2000);
+    }
+  } catch (err) {
+    console.error("❌ Failed to get service status:", err);
+    process.exit(1);
+  }
+}
+
+async function getLinuxServices(): Promise<ServiceStatus[]> {
+  const services: ServiceStatus[] = [];
+  
+  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"));
+    
+    for (const line of lines) {
+      const match = line.match(/^(?:\s*([●\s○]))?\s*([^\s]+)\.service\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+(.+)$/);
+      if (!match) continue;
       
-      // Display table
-      console.clear();
-      console.log("🔍 BSN Service Status\n");
+      const [, statusIndicator, name, loaded, active, sub, description] = match;
       
-      if (services.length === 0) {
-        console.log("No BSN-managed services running.");
-        return;
-      }
+      if (!description.includes("Bun Service:") && !description.includes("BS9 Service:")) continue;
       
-      // Header
-      console.log(`${"SERVICE".padEnd(20)} ${"STATE".padEnd(12)} ${"CPU".padEnd(8)} ${"MEMORY".padEnd(10)} ${"UPTIME".padEnd(12)} ${"TASKS".padEnd(6)} DESCRIPTION`);
-      console.log("-".repeat(90));
+      const status: ServiceStatus = {
+        name,
+        loaded,
+        active,
+        sub,
+        description,
+      };
       
-      for (const svc of services) {
-        const state = `${svc.active}/${svc.sub}`;
-        console.log(
-          `${svc.name.padEnd(20)} ${state.padEnd(12)} ${(svc.cpu || "-").padEnd(8)} ${(svc.memory || "-").padEnd(10)} ${(svc.uptime || "-").padEnd(12)} ${(svc.tasks || "-").padEnd(6)} ${svc.description}`
-        );
+      // Get additional metrics
+      try {
+        const showOutput = execSync(`systemctl --user show ${name} -p CPUUsageNSec MemoryCurrent ActiveEnterTimestamp TasksCurrent`, { 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) status.cpu = formatCPU(Number(cpuMatch[1]));
+        if (memMatch) status.memory = formatMemory(Number(memMatch[1]));
+        if (timeMatch) status.uptime = formatUptime(timeMatch[1]);
+        if (tasksMatch) status.tasks = tasksMatch[1];
+      } catch {
+        // Metrics might not be available
       }
       
-      console.log("\n📊 SRE Metrics Summary:");
-      const totalServices = services.length;
-      const runningServices = services.filter(s => s.active === "active").length;
-      const totalMemory = services.reduce((sum, s) => sum + (s.memory ? parseMemory(s.memory) : 0), 0);
-      
-      console.log(`  Services: ${runningServices}/${totalServices} running`);
-      console.log(`  Memory: ${formatMemory(totalMemory)}`);
-      console.log(`  Last updated: ${new Date().toISOString()}`);
-      
-    } catch (err) {
-      console.error(`❌ Failed to get status: ${err}`);
-      process.exit(1);
+      services.push(status);
     }
-  };
-  
-  if (options.watch) {
-    console.log("🔄 Watch mode (Ctrl+C to exit)\n");
-    const interval = setInterval(doStatus, 2000);
-    process.on("SIGINT", () => {
-      clearInterval(interval);
-      console.log("\n👋 Exiting watch mode");
-      process.exit(0);
-    });
-    doStatus();
-  } else {
-    doStatus();
+  } catch (error) {
+    console.warn("Failed to get Linux services:", error);
   }
+  
+  return services;
+}
+
+async function getMacOSServices(): Promise<ServiceStatus[]> {
+  const services: ServiceStatus[] = [];
+  
+  try {
+    const { launchdCommand } = await import("../macos/launchd.js");
+    // For now, return empty array - would need to implement status in launchd.ts
+  } catch (error) {
+    console.warn("Failed to get macOS services:", error);
+  }
+  
+  return services;
+}
+
+async function getWindowsServices(): Promise<ServiceStatus[]> {
+  const services: ServiceStatus[] = [];
+  
+  try {
+    const { windowsCommand } = await import("../windows/service.js");
+    // For now, return empty array - would need to implement status in windows/service.ts
+  } catch (error) {
+    console.warn("Failed to get Windows services:", error);
+  }
+  
+  return services;
+}
+
+function displayServices(services: ServiceStatus[]): void {
+  // Header
+  console.log(`${"SERVICE".padEnd(20)} ${"STATE".padEnd(12)} ${"CPU".padEnd(8)} ${"MEMORY".padEnd(10)} ${"UPTIME".padEnd(12)} ${"TASKS".padEnd(6)} DESCRIPTION`);
+  console.log("-".repeat(90));
+  
+  for (const svc of services) {
+    const state = `${svc.active}/${svc.sub}`;
+    console.log(
+      `${svc.name.padEnd(20)} ${state.padEnd(12)} ${(svc.cpu || "-").padEnd(8)} ${(svc.memory || "-").padEnd(10)} ${(svc.uptime || "-").padEnd(12)} ${(svc.tasks || "-").padEnd(6)} ${svc.description}`
+    );
+  }
+  
+  console.log("\n📊 SRE Metrics Summary:");
+  const totalServices = services.length;
+  const runningServices = services.filter(s => s.active === "active").length;
+  const totalMemory = services.reduce((sum, s) => sum + (s.memory ? parseMemory(s.memory) : 0), 0);
+  
+  console.log(`  Services: ${runningServices}/${totalServices} running`);
+  console.log(`  Memory: ${formatMemory(totalMemory)}`);
+  console.log(`  Last updated: ${new Date().toISOString()}`);
 }
 
 function formatCPU(nsec: number): string {
@@ -132,31 +165,43 @@ function formatCPU(nsec: number): string {
 function formatMemory(bytes: number): string {
   const units = ["B", "KB", "MB", "GB"];
   let size = bytes;
-  let unit = 0;
-  while (size >= 1024 && unit < units.length - 1) {
+  let unitIndex = 0;
+  
+  while (size >= 1024 && unitIndex < units.length - 1) {
     size /= 1024;
-    unit++;
+    unitIndex++;
   }
-  return `${size.toFixed(1)}${units[unit]}`;
+  
+  return `${size.toFixed(1)}${units[unitIndex]}`;
 }
 
-function parseMemory(str: string): number {
-  const match = str.match(/^([\d.]+)(B|KB|MB|GB)$/);
+function parseMemory(memStr: string): number {
+  const match = memStr.match(/^([\d.]+)(B|KB|MB|GB)$/);
   if (!match) return 0;
+  
   const [, value, unit] = match;
-  const mult = { B: 1, KB: 1024, MB: 1024 ** 2, GB: 1024 ** 3 }[unit] || 1;
-  return Number(value) * mult;
+  const num = parseFloat(value);
+  
+  switch (unit) {
+    case "KB": return num * 1024;
+    case "MB": return num * 1024 * 1024;
+    case "GB": return num * 1024 * 1024 * 1024;
+    default: return num;
+  }
 }
 
 function 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));
-    return `${hours}h ${minutes}m`;
-  } catch {
-    return "-";
-  }
+  const date = new Date(timestamp);
+  const now = new Date();
+  const diff = now.getTime() - date.getTime();
+  
+  const seconds = Math.floor(diff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
 }

package/src/commands/stop.ts

@@ -1,13 +1,41 @@
 #!/usr/bin/env bun
 
 import { execSync } from "node:child_process";
+import { join } from "node:path";
+import { getPlatformInfo } from "../platform/detect.js";
+
+// Security: Service name validation
+function isValidServiceName(name: string): boolean {
+  // Only allow alphanumeric, hyphens, underscores, and dots
+  // Prevent command injection and path traversal
+  const validPattern = /^[a-zA-Z0-9._-]+$/;
+  return validPattern.test(name) && name.length <= 64 && !name.includes('..') && !name.includes('/');
+}
 
 export async function stopCommand(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 stop ${name}`, { stdio: "inherit" });
-    console.log(`🛑 User service '${name}' stopped`);
+    if (platformInfo.isLinux) {
+      // Security: Use shell escaping to prevent injection
+      const escapedName = name.replace(/[^a-zA-Z0-9._-]/g, '');
+      execSync(`systemctl --user stop "${escapedName}"`, { stdio: "inherit" });
+      console.log(`🛑 User service '${name}' stopped`);
+    } else if (platformInfo.isMacOS) {
+      const { launchdCommand } = await import("../macos/launchd.js");
+      await launchdCommand('stop', { name: `bs9.${name}` });
+    } else if (platformInfo.isWindows) {
+      const { windowsCommand } = await import("../windows/service.js");
+      await windowsCommand('stop', { name: `BS9_${name}` });
+    }
   } catch (err) {
-    console.error(`❌ Failed to stop user service '${name}': ${err}`);
+    console.error(`❌ Failed to stop service '${name}': ${err}`);
     process.exit(1);
   }
 }

package/src/commands/web.ts

@@ -2,26 +2,50 @@
 
 import { execSync } from "node:child_process";
 import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
 
 interface WebOptions {
   port?: string;
   detach?: boolean;
 }
 
+// Security: Port validation
+function isValidPort(port: string): boolean {
+  const portNum = Number(port);
+  return !isNaN(portNum) && portNum >= 1 && portNum <= 65535;
+}
+
+// Security: Generate secure session token
+function generateSessionToken(): string {
+  return randomBytes(32).toString('hex');
+}
+
 export async function webCommand(options: WebOptions): Promise<void> {
+  // Security: Validate port
   const port = options.port || "8080";
+  if (!isValidPort(port)) {
+    console.error(`❌ Security: Invalid port number: ${port}. Must be 1-65535`);
+    process.exit(1);
+  }
+  
   const dashboardPath = `${import.meta.dir}/../web/dashboard.ts`;
   
+  // Security: Generate session token for authentication
+  const sessionToken = generateSessionToken();
+  
   console.log(`🌐 Starting BS9 Web Dashboard on port ${port}`);
+  console.log(`🔐 Session Token: ${sessionToken}`);
   
   if (options.detach) {
-    // Run in background
+    // Run in background with security
     const child = spawn("bun", ["run", dashboardPath], {
       detached: true,
       stdio: 'ignore',
       env: {
         ...process.env,
         WEB_DASHBOARD_PORT: port,
+        WEB_SESSION_TOKEN: sessionToken,
+        NODE_ENV: "production",
       },
     });
     
@@ -31,14 +55,16 @@ export async function webCommand(options: WebOptions): Promise<void> {
     console.log(`   URL: http://localhost:${port}`);
     console.log(`   Process ID: ${child.pid}`);
     console.log(`   Stop with: kill ${child.pid}`);
+    console.log(`   🔐 Use session token for API access`);
   } else {
-    // Run in foreground
+    // Run in foreground with security
     console.log(`   URL: http://localhost:${port}`);
+    console.log(`   🔐 Session token: ${sessionToken}`);
     console.log(`   Press Ctrl+C to stop`);
     console.log('');
     
     try {
-      execSync(`WEB_DASHBOARD_PORT=${port} bun run ${dashboardPath}`, { 
+      execSync(`WEB_DASHBOARD_PORT=${port} WEB_SESSION_TOKEN=${sessionToken} NODE_ENV=production bun run ${dashboardPath}`, { 
         stdio: "inherit" 
       });
     } catch (error) {