bs9 1.4.3 → 1.4.6

package/dist/bs9-zmxbnn8g.

@@ -0,0 +1,255 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+
+// Read version from package.json
+const packageJsonPath = join(dirname(import.meta.path), '..', 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+const version = packageJson.version;
+
+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 { deleteCommand } from "../src/commands/delete.js";
+import { saveCommand } from "../src/commands/save.js";
+import { resurrectCommand } from "../src/commands/resurrect.js";
+import { deployCommand } from "../src/commands/deploy.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";
+import { doctorCommand } from "../src/commands/doctor.js";
+
+const program = new Command();
+
+program
+  .name("bs9")
+  .description("BS9 (Bun Sentinel 9) — Mission-critical process manager CLI")
+  .version(version);
+
+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("--flamegraph", "Generate flame graph")
+  .option("--top <number>", "Show top N functions", "10")
+  .action(profileCommand);
+
+program
+  .command("delete")
+  .description("Delete managed services")
+  .argument("[name]", "Service name (optional)")
+  .option("-a, --all", "Delete all services")
+  .option("-f, --force", "Force deletion without errors")
+  .option("-r, --remove", "Remove service configuration files")
+  .option("-t, --timeout <seconds>", "Timeout for graceful shutdown (default: 30)")
+  .action(deleteCommand);
+
+program
+  .command("save")
+  .description("Save service configurations to backup")
+  .argument("[name]", "Service name (optional)")
+  .option("-a, --all", "Save all services")
+  .option("-f, --force", "Force save without errors")
+  .option("-b, --backup", "Create timestamped backup")
+  .action(saveCommand);
+
+program
+  .command("resurrect")
+  .description("Resurrect services from backup")
+  .argument("[name]", "Service name (optional)")
+  .option("-a, --all", "Resurrect all services")
+  .option("-f, --force", "Force resurrection without errors")
+  .option("-c, --config <file>", "Configuration file to use")
+  .action(resurrectCommand);
+
+program
+  .command("deploy")
+  .description("🚀 Deploy applications with zero-config production setup")
+  .argument("<file>", "Application file to deploy")
+  .option("-n, --name <name>", "Service name")
+  .option("-p, --port <port>", "Port number", "3000")
+  .option("-h, --host <host>", "Host address", "localhost")
+  .option("-e, --env <env>", "Environment variables (multiple)", (value, previous) => [...(previous || []), value])
+  .option("-i, --instances <number>", "Number of instances")
+  .option("--memory <memory>", "Memory limit")
+  .option("--cpu <cpu>", "CPU limit")
+  .option("--log-level <level>", "Log level")
+  .option("--log-file <file>", "Log file path")
+  .option("--restart <policy>", "Restart policy")
+  .option("--no-health", "Skip health check")
+  .option("--no-metrics", "Disable metrics")
+  .option("--no-otel", "Disable OpenTelemetry")
+  .option("--no-prometheus", "Disable Prometheus")
+  .option("--https", "Enable HTTPS")
+  .option("--no-linger", "Don't enable linger")
+  .option("-f, --force", "Force deployment")
+  .option("--reload", "Reload existing service")
+  .option("--build", "Build TypeScript")
+  .action(deployCommand);
+
+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
+  .command("doctor")
+  .description("Perform comprehensive health check")
+  .option("--check <type>", "Specific check to run (dependencies|configuration|platform)")
+  .option("-v, --verbose", "Verbose output with system information")
+  .action(doctorCommand);
+
+program.parse();

package/dist/bs9.js

@@ -1,6 +1,6 @@
 // @bun
 // bin/bs9
-var bs9_default = "./bs9-bbkpq14n.";
+var bs9_default = "./bs9-nfpea7ta.";
 export {
   bs9_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bs9",
-  "version": "1.4.3",
+  "version": "1.4.6",
   "description": "Bun Sentinel 9 - High-performance, non-root process manager for Bun",
   "type": "module",
   "main": "src/index.ts",

package/src/commands/deploy.ts

@@ -237,12 +237,6 @@ function showDeploymentSummary(serviceName: string, options: DeployOptions): voi
   console.log(`  bs9 delete ${serviceName}`);
   console.log(`  bs9 save ${serviceName}`);
   
-  console.log("\n🌟 KILLER FEATURES:");
-  console.log("  ✅ Zero-config systemd setup");
-  console.log("  ✅ Built-in health checks & restart policies");
-  console.log("  ✅ Hot reload with environment updates");
-  console.log("  ✅ Automatic metrics & observability");
-  console.log("  ✅ One-command deployment");
-  
+
   console.log("\n🚀 Your service is now running in production mode!");
 }

package/src/commands/doctor.ts

@@ -0,0 +1,332 @@
+#!/usr/bin/env bun
+
+/**
+ * BS9 - Bun Sentinel 9
+ * High-performance, non-root process manager for Bun
+ * 
+ * Copyright (c) 2026 BS9 (Bun Sentinel 9)
+ * Licensed under the MIT License
+ * https://github.com/xarhang/bs9
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getPlatformInfo } from "../platform/detect.js";
+
+interface DoctorOptions {
+  check?: string;
+  verbose?: boolean;
+}
+
+interface HealthCheck {
+  name: string;
+  status: "✅ PASS" | "❌ FAIL" | "⚠️ WARN";
+  message: string;
+  details?: string;
+}
+
+export async function doctorCommand(options: DoctorOptions): Promise<void> {
+  console.log("🏥 BS9 Health Check & Diagnostics");
+  console.log("=".repeat(80));
+  
+  const checks: HealthCheck[] = [];
+  const platformInfo = getPlatformInfo();
+  
+  // Basic installation checks
+  checks.push(checkBunInstallation());
+  checks.push(checkBS9Installation());
+  checks.push(checkPlatformDetection(platformInfo));
+  
+  // Directory structure checks
+  checks.push(checkDirectoryStructure(platformInfo));
+  checks.push(checkPermissions(platformInfo));
+  
+  // Service manager checks
+  checks.push(checkServiceManager(platformInfo));
+  
+  // Network and connectivity checks
+  checks.push(checkNetworkConnectivity());
+  
+  // Optional checks based on flags
+  if (options.check) {
+    const specificChecks = runSpecificCheck(options.check, platformInfo);
+    checks.push(...specificChecks);
+  }
+  
+  if (options.verbose) {
+    checks.push(checkSystemResources());
+    checks.push(checkDependencies());
+  }
+  
+  // Display results
+  displayResults(checks);
+  
+  // Summary
+  const passed = checks.filter(c => c.status === "✅ PASS").length;
+  const failed = checks.filter(c => c.status === "❌ FAIL").length;
+  const warnings = checks.filter(c => c.status === "⚠️ WARN").length;
+  
+  console.log("\n" + "=".repeat(80));
+  console.log(`📊 Health Check Summary:`);
+  console.log(`   ✅ Passed: ${passed}`);
+  console.log(`   ❌ Failed: ${failed}`);
+  console.log(`   ⚠️ Warnings: ${warnings}`);
+  console.log(`   📈 Total: ${checks.length}`);
+  
+  if (failed > 0) {
+    console.log(`\n❌ Health check FAILED with ${failed} error(s)`);
+    console.log("💡 Run 'bs9 doctor --verbose' for more details");
+    process.exit(1);
+  } else {
+    console.log(`\n✅ Health check PASSED - BS9 is ready to use!`);
+  }
+}
+
+function checkBunInstallation(): HealthCheck {
+  try {
+    const version = execSync("bun --version", { encoding: "utf-8" }).trim();
+    return {
+      name: "Bun Installation",
+      status: "✅ PASS",
+      message: `Bun v${version} installed`,
+      details: `Runtime: ${version}`
+    };
+  } catch {
+    return {
+      name: "Bun Installation",
+      status: "❌ FAIL",
+      message: "Bun is not installed or not in PATH",
+      details: "Install Bun from https://bun.sh"
+    };
+  }
+}
+
+function checkBS9Installation(): HealthCheck {
+  try {
+    const version = execSync("bs9 --version", { encoding: "utf-8" }).trim();
+    return {
+      name: "BS9 Installation",
+      status: "✅ PASS",
+      message: `BS9 ${version} installed`,
+      details: `CLI: ${version}`
+    };
+  } catch {
+    return {
+      name: "BS9 Installation",
+      status: "❌ FAIL",
+      message: "BS9 is not installed or not in PATH",
+      details: "Run 'npm install -g bs9' or install from source"
+    };
+  }
+}
+
+function checkPlatformDetection(platformInfo: any): HealthCheck {
+  return {
+    name: "Platform Detection",
+    status: "✅ PASS",
+    message: `Detected ${platformInfo.platform}`,
+    details: `OS: ${platformInfo.platform}, Service Manager: ${platformInfo.serviceManager}`
+  };
+}
+
+function checkDirectoryStructure(platformInfo: any): HealthCheck {
+  const requiredDirs = [
+    platformInfo.configDir,
+    platformInfo.logDir,
+    platformInfo.serviceDir
+  ];
+  
+  const missingDirs = requiredDirs.filter(dir => !existsSync(dir));
+  
+  if (missingDirs.length === 0) {
+    return {
+      name: "Directory Structure",
+      status: "✅ PASS",
+      message: "All required directories exist",
+      details: `Config: ${platformInfo.configDir}`
+    };
+  } else {
+    return {
+      name: "Directory Structure",
+      status: "❌ FAIL",
+      message: `Missing ${missingDirs.length} directories`,
+      details: `Missing: ${missingDirs.join(", ")}`
+    };
+  }
+}
+
+function checkPermissions(platformInfo: any): HealthCheck {
+  try {
+    // Test write permissions
+    const testFile = join(platformInfo.configDir, ".bs9-test");
+    execSync(`touch "${testFile}"`, { stdio: "ignore" });
+    execSync(`rm "${testFile}"`, { stdio: "ignore" });
+    
+    return {
+      name: "File Permissions",
+      status: "✅ PASS",
+      message: "Write permissions OK",
+      details: `Can write to ${platformInfo.configDir}`
+    };
+  } catch {
+    return {
+      name: "File Permissions",
+      status: "❌ FAIL",
+      message: "Insufficient file permissions",
+      details: `Cannot write to ${platformInfo.configDir}`
+    };
+  }
+}
+
+function checkServiceManager(platformInfo: any): HealthCheck {
+  try {
+    switch (platformInfo.platform) {
+      case "linux":
+        execSync("systemctl --user --version", { stdio: "ignore" });
+        return {
+          name: "Service Manager",
+          status: "✅ PASS",
+          message: "systemd user services available",
+          details: "systemd user mode is working"
+        };
+      
+      case "darwin":
+        execSync("launchctl list", { stdio: "ignore" });
+        return {
+          name: "Service Manager",
+          status: "✅ PASS",
+          message: "launchd available",
+          details: "macOS launchd is working"
+        };
+      
+      case "win32":
+        execSync("sc query", { stdio: "ignore" });
+        return {
+          name: "Service Manager",
+          status: "✅ PASS",
+          message: "Windows Services available",
+          details: "Windows Service Manager is working"
+        };
+      
+      default:
+        return {
+          name: "Service Manager",
+          status: "⚠️ WARN",
+          message: "Unsupported platform",
+          details: `Platform ${platformInfo.platform} may have limited support`
+        };
+    }
+  } catch {
+    return {
+      name: "Service Manager",
+      status: "❌ FAIL",
+      message: "Service manager not available",
+      details: "Cannot access system service manager"
+    };
+  }
+}
+
+function checkNetworkConnectivity(): HealthCheck {
+  try {
+    // Test basic network connectivity
+    execSync("curl -s --connect-timeout 3 http://httpbin.org/ip", { stdio: "ignore" });
+    return {
+      name: "Network Connectivity",
+      status: "✅ PASS",
+      message: "Network connectivity OK",
+      details: "Can reach external services"
+    };
+  } catch {
+    return {
+      name: "Network Connectivity",
+      status: "⚠️ WARN",
+      message: "Limited network connectivity",
+      details: "Cannot reach external services (may be offline)"
+    };
+  }
+}
+
+function checkSystemResources(): HealthCheck {
+  try {
+    const memory = execSync("free -h", { encoding: "utf-8" });
+    const disk = execSync("df -h .", { encoding: "utf-8" });
+    
+    return {
+      name: "System Resources",
+      status: "✅ PASS",
+      message: "System resources OK",
+      details: `Memory and disk space available`
+    };
+  } catch {
+    return {
+      name: "System Resources",
+      status: "⚠️ WARN",
+      message: "Cannot check system resources",
+      details: "Resource monitoring not available"
+    };
+  }
+}
+
+function checkDependencies(): HealthCheck {
+  try {
+    const packageJson = JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8"));
+    const deps = Object.keys(packageJson.dependencies || {});
+    
+    return {
+      name: "Dependencies",
+      status: "✅ PASS",
+      message: `${deps.length} dependencies found`,
+      details: `Dependencies: ${deps.slice(0, 3).join(", ")}${deps.length > 3 ? "..." : ""}`
+    };
+  } catch {
+    return {
+      name: "Dependencies",
+      status: "⚠️ WARN",
+      message: "No package.json found",
+      details: "Not in a Node.js project directory"
+    };
+  }
+}
+
+function runSpecificCheck(check: string, platformInfo: any): HealthCheck[] {
+  const checks: HealthCheck[] = [];
+  
+  switch (check.toLowerCase()) {
+    case "dependencies":
+      checks.push(checkDependencies());
+      break;
+    
+    case "configuration":
+      checks.push(checkDirectoryStructure(platformInfo));
+      checks.push(checkPermissions(platformInfo));
+      break;
+    
+    case "platform":
+      checks.push(checkPlatformDetection(platformInfo));
+      checks.push(checkServiceManager(platformInfo));
+      break;
+    
+    default:
+      checks.push({
+        name: "Specific Check",
+        status: "❌ FAIL",
+        message: `Unknown check: ${check}`,
+        details: "Available checks: dependencies, configuration, platform"
+      });
+  }
+  
+  return checks;
+}
+
+function displayResults(checks: HealthCheck[]): void {
+  console.log("\n🔍 Health Check Results:");
+  console.log("-".repeat(80));
+  
+  for (const check of checks) {
+    console.log(`${check.status} ${check.name}: ${check.message}`);
+    if (check.details) {
+      console.log(`   📋 ${check.details}`);
+    }
+  }
+}