bs9 1.3.7 → 1.3.8

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.3.5-blue.svg)](https://github.com/xarhang/bs9)
+[![Version](https://img.shields.io/badge/version-1.3.7-blue.svg)](https://github.com/xarhang/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)
@@ -98,6 +98,20 @@ bs9 alert --test                   # Test webhook
 bs9 export --format json --hours 24 # Export metrics
 bs9 export --service myapp --format csv --hours 24
 bs9 export --service myapp --format csv
+
+# Service management
+bs9 delete myapp                    # Delete specific service
+bs9 delete myapp --remove           # Delete and remove config files
+bs9 delete --all                    # Delete all services
+bs9 delete --all --force           # Force delete all services
+bs9 delete myapp --timeout 60      # Custom graceful shutdown timeout
+
+# Backup and restore
+bs9 save myapp                     # Save service configuration
+bs9 save --all                     # Save all services
+bs9 save myapp --backup            # Save with timestamped backup
+bs9 resurrect myapp                # Restore from backup
+bs9 resurrect --all               # Restore all services
 ```
 
 ---
@@ -123,6 +137,22 @@ bs9 export --service myapp --format csv
 - **Cooldown Period**: Prevent alert spam
 - **Alert Testing**: Webhook connectivity validation
 
+### 🗑️ Service Deletion & Cleanup
+- **Individual Service Deletion**: Delete specific services by name
+- **Bulk Deletion**: Remove all BS9 services at once
+- **Configuration Cleanup**: Remove service configuration files
+- **Force Deletion**: Ignore errors during deletion
+- **Graceful Shutdown**: Configurable timeout for clean termination
+- **Cross-Platform Support**: Works on Linux, macOS, and Windows
+
+### 💾 Backup & Restore System
+- **Service Configuration Backup**: Save service configurations to JSON
+- **Bulk Backup**: Save all services at once
+- **Timestamped Backups**: Create multiple backup versions
+- **Service Resurrection**: Restore services from backup
+- **Configuration Management**: Manage service configurations
+- **Disaster Recovery**: Quick service restoration
+
 ### 🐳 Container & Orchestration
 - **Docker Support**: Complete Dockerfile and docker-compose setup
 - **Kubernetes**: Full K8s deployment with ServiceMonitor
@@ -303,6 +333,9 @@ kubectl get pods -n bs9-system
 | - | `bs9 web` | Web-based dashboard |
 | - | `bs9 alert` | Alert system with webhooks |
 | - | `bs9 export` | Historical metrics |
+| - | `bs9 delete` | Service deletion and cleanup |
+| - | `bs9 save` | Service configuration backup |
+| - | `bs9 resurrect` | Service restoration from backup |
 
 ---
 
@@ -453,6 +486,9 @@ BS9/
 │   │   ├── monit.ts        # Terminal dashboard
 │   │   ├── web.ts          # Web dashboard
 │   │   ├── alert.ts        # Alert management
+│   │   ├── delete.ts       # Service deletion
+│   │   ├── save.ts         # Service backup
+│   │   ├── resurrect.ts    # Service restoration
 │   │   └── export.ts       # Data export
 │   ├── web/                # Web dashboard
 │   │   └── dashboard.ts    # Web server

package/bin/bs9

@@ -21,6 +21,8 @@ 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 { loadbalancerCommand } from "../src/loadbalancer/manager.js";
 import { windowsCommand } from "../src/windows/service.js";
 import { launchdCommand } from "../src/macos/launchd.js";
@@ -138,9 +140,27 @@ program
   .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", "30")
+  .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("loadbalancer")
   .description("Load balancer management")

package/dist/bs9-xvqzb6v3.

@@ -0,0 +1,221 @@
+#!/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 { 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(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("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,6 +1,6 @@
 // @bun
 // bin/bs9
-var bs9_default = "./bs9-6h4w11ar.";
+var bs9_default = "./bs9-xvqzb6v3.";
 export {
   bs9_default as default
 };

package/package.json

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

package/src/commands/delete.ts

@@ -118,7 +118,7 @@ async function deleteAllServices(platformInfo: any, options: DeleteOptions): Pro
       for (const line of lines) {
         const match = line.match(/^(?:\s*([●\s○]))?\s*([^\s]+)\.service\s+([^\s]+)\s+([^\s]+)\s+(.+)$/);
         if (match) {
-          const [, serviceName] = match;
+          const [, , serviceName] = match; // Skip the status symbol, capture service name
           
           // Only process BS9 services
           if (match[5].includes("Bun Service:") || match[5].includes("BS9 Service:")) {

package/src/commands/resurrect.ts

@@ -0,0 +1,171 @@
+#!/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 { join } from "node:path";
+import { getPlatformInfo } from "../platform/detect.js";
+
+interface ResurrectOptions {
+  all?: boolean;
+  force?: boolean;
+  config?: string;
+}
+
+// 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 resurrectCommand(name: string, options: ResurrectOptions): Promise<void> {
+  const platformInfo = getPlatformInfo();
+  
+  // Handle resurrect all services
+  if (options.all) {
+    await resurrectAllServices(platformInfo, options);
+    return;
+  }
+  
+  // Security: Validate service name
+  if (!isValidServiceName(name)) {
+    console.error(`❌ Security: Invalid service name: ${name}`);
+    process.exit(1);
+  }
+  
+  try {
+    if (platformInfo.isLinux) {
+      // Security: Use shell escaping to prevent injection
+      const escapedName = name.replace(/[^a-zA-Z0-9._-]/g, '');
+      
+      // Check if service exists in backup
+      const backupDir = join(platformInfo.configDir, 'backups');
+      const backupFile = join(backupDir, `${escapedName}.json`);
+      
+      if (!require('node:fs').existsSync(backupFile)) {
+        console.error(`❌ No backup found for service '${name}'`);
+        process.exit(1);
+      }
+      
+      // Load backup configuration
+      const backupConfig = JSON.parse(require('node:fs').readFileSync(backupFile, 'utf8'));
+      
+      // Restore service using backup configuration
+      const { startCommand } = await import("./start.js");
+      await startCommand(backupConfig.file, {
+        name: backupConfig.name,
+        port: backupConfig.port?.toString(),
+        host: backupConfig.host,
+        env: backupConfig.env,
+        otel: backupConfig.otel,
+        prometheus: backupConfig.prometheus,
+        build: backupConfig.build,
+        https: backupConfig.https
+      });
+      
+      console.log(`✅ Service '${name}' resurrected successfully from backup`);
+      
+    } else if (platformInfo.isMacOS) {
+      const { launchdCommand } = await import("../macos/launchd.js");
+      await launchdCommand('resurrect', { name: `bs9.${name}` });
+      
+      if (options.config) {
+        const plistFile = join(platformInfo.serviceDir, `bs9.${name}.plist`);
+        try {
+          require('node:fs').writeFileSync(plistFile, options.config);
+          console.log(`📝 Configuration restored: ${plistFile}`);
+        } catch (error) {
+          console.error(`❌ Failed to restore configuration: ${error}`);
+        }
+      }
+      
+      console.log(`✅ Service '${name}' resurrected successfully`);
+      
+    } else if (platformInfo.isWindows) {
+      const { windowsCommand } = await import("../windows/service.js");
+      await windowsCommand('resurrect', { name: `BS9_${name}` });
+      
+      console.log(`✅ Service '${name}' resurrected successfully`);
+    }
+  } catch (err) {
+    console.error(`❌ Failed to resurrect service '${name}': ${err}`);
+    if (!options.force) {
+      process.exit(1);
+    }
+  }
+}
+
+async function resurrectAllServices(platformInfo: any, options: ResurrectOptions): Promise<void> {
+  try {
+    console.log("🔄 Resurrecting all BS9 services from backup...");
+    
+    if (platformInfo.isLinux) {
+      const backupDir = join(platformInfo.configDir, 'backups');
+      
+      if (!require('node:fs').existsSync(backupDir)) {
+        console.log("ℹ️ No backup directory found");
+        return;
+      }
+      
+      // Get all backup files
+      const backupFiles = require('node:fs').readdirSync(backupDir)
+        .filter((file: string) => file.endsWith('.json'));
+      
+      if (backupFiles.length === 0) {
+        console.log("ℹ️ No backup files found to resurrect");
+        return;
+      }
+      
+      console.log(`Found ${backupFiles.length} backup files to restore...`);
+      
+      for (const backupFile of backupFiles) {
+        try {
+          const serviceName = backupFile.replace('.json', '');
+          const backupPath = join(backupDir, backupFile);
+          const backupConfig = JSON.parse(require('node:fs').readFileSync(backupPath, 'utf8'));
+          
+          // Restore service using backup configuration
+          const { startCommand } = await import("./start.js");
+          await startCommand(backupConfig.file, {
+            name: backupConfig.name,
+            port: backupConfig.port?.toString(),
+            host: backupConfig.host,
+            env: backupConfig.env,
+            otel: backupConfig.otel,
+            prometheus: backupConfig.prometheus,
+            build: backupConfig.build,
+            https: backupConfig.https
+          });
+          
+          console.log(`  ✅ Resurrected service: ${serviceName}`);
+        } catch (error) {
+          console.error(`  ⚠️  Failed to resurrect service '${backupFile}': ${error}`);
+        }
+      }
+      
+    } else if (platformInfo.isMacOS) {
+      console.log("📝 To resurrect all services on macOS, you need to manually restore the plist files from:");
+      console.log(`   ${join(platformInfo.configDir, 'backups')}/*.plist`);
+      console.log("   And then run: launchctl load ~/Library/LaunchAgents/bs9.*.plist");
+    } else if (platformInfo.isWindows) {
+      console.log("📝 To resurrect all services on Windows, use PowerShell:");
+      console.log("   Get-ChildItem -Path \"${join(platformInfo.configDir, 'backups')}\" | ForEach-Object { Restore-Service $_.Name }");
+    }
+    
+    console.log(`✅ All BS9 services resurrection process completed`);
+  } catch (err) {
+    console.error(`❌ Failed to resurrect all services: ${err}`);
+    if (!options.force) {
+      process.exit(1);
+    }
+  }
+}

package/src/commands/save.ts

@@ -0,0 +1,249 @@
+#!/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 { join } from "node:path";
+import { getPlatformInfo } from "../platform/detect.js";
+
+interface SaveOptions {
+  all?: boolean;
+  force?: boolean;
+  backup?: boolean;
+}
+
+// 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 saveCommand(name: string, options: SaveOptions): Promise<void> {
+  const platformInfo = getPlatformInfo();
+  
+  // Handle save all services
+  if (options.all) {
+    await saveAllServices(platformInfo, options);
+    return;
+  }
+  
+  // Security: Validate service name
+  if (!isValidServiceName(name)) {
+    console.error(`❌ Security: Invalid service name: ${name}`);
+    process.exit(1);
+  }
+  
+  try {
+    if (platformInfo.isLinux) {
+      // Security: Use shell escaping to prevent injection
+      const escapedName = name.replace(/[^a-zA-Z0-9._-]/g, '');
+      
+      // Get service status and configuration
+      const statusOutput = execSync(`systemctl --user show "${escapedName}"`, { encoding: "utf-8" });
+      const serviceFile = join(platformInfo.serviceDir, `${escapedName}.service`);
+      
+      if (!require('node:fs').existsSync(serviceFile)) {
+        console.error(`❌ Service configuration not found for '${name}'`);
+        process.exit(1);
+      }
+      
+      // Read service configuration
+      const serviceConfig = require('node:fs').readFileSync(serviceFile, 'utf8');
+      
+      // Parse service configuration to extract startup parameters
+      const config = parseServiceConfig(serviceConfig, statusOutput);
+      
+      // Create backup directory if it doesn't exist
+      const backupDir = join(platformInfo.configDir, 'backups');
+      require('node:fs').mkdirSync(backupDir, { recursive: true });
+      
+      // Save configuration to backup
+      const backupFile = join(backupDir, `${escapedName}.json`);
+      const backupData = {
+        name: name,
+        file: extractFileFromConfig(serviceConfig),
+        port: config.port,
+        host: config.host,
+        env: config.env,
+        otel: config.otel,
+        prometheus: config.prometheus,
+        build: config.build,
+        https: config.https,
+        savedAt: new Date().toISOString(),
+        platform: platformInfo.platform
+      };
+      
+      require('node:fs').writeFileSync(backupFile, JSON.stringify(backupData, null, 2));
+      
+      console.log(`💾 Service '${name}' configuration saved to: ${backupFile}`);
+      
+      if (options.backup) {
+        // Create additional backup with timestamp
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const timestampedBackup = join(backupDir, `${escapedName}-${timestamp}.json`);
+        require('node:fs').writeFileSync(timestampedBackup, JSON.stringify(backupData, null, 2));
+        console.log(`📦 Additional backup created: ${timestampedBackup}`);
+      }
+      
+    } else if (platformInfo.isMacOS) {
+      const { launchdCommand } = await import("../macos/launchd.js");
+      await launchdCommand('save', { name: `bs9.${name}` });
+      
+      console.log(`💾 Service '${name}' configuration saved`);
+      
+    } else if (platformInfo.isWindows) {
+      const { windowsCommand } = await import("../windows/service.js");
+      await windowsCommand('save', { name: `BS9_${name}` });
+      
+      console.log(`💾 Service '${name}' configuration saved`);
+    }
+  } catch (err) {
+    console.error(`❌ Failed to save service '${name}': ${err}`);
+    if (!options.force) {
+      process.exit(1);
+    }
+  }
+}
+
+async function saveAllServices(platformInfo: any, options: SaveOptions): Promise<void> {
+  try {
+    console.log("💾 Saving all BS9 service configurations...");
+    
+    if (platformInfo.isLinux) {
+      // 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"));
+      
+      const bs9Services: string[] = [];
+      
+      for (const line of lines) {
+        const match = line.match(/^(?:\s*([●\s○]))?\s*([^\s]+)\.service\s+([^\s]+)\s+([^\s]+)\s+(.+)$/);
+        if (match) {
+          const [, , serviceName] = match; // Skip the status symbol, capture service name
+          
+          // Only process BS9 services
+          if (match[5].includes("Bun Service:") || match[5].includes("BS9 Service:")) {
+            bs9Services.push(serviceName);
+          }
+        }
+      }
+      
+      if (bs9Services.length === 0) {
+        console.log("ℹ️ No BS9 services found to save");
+        return;
+      }
+      
+      console.log(`Found ${bs9Services.length} BS9 services to save...`);
+      
+      // Create backup directory
+      const backupDir = join(platformInfo.configDir, 'backups');
+      require('node:fs').mkdirSync(backupDir, { recursive: true });
+      
+      for (const serviceName of bs9Services) {
+        try {
+          const serviceFile = join(platformInfo.serviceDir, `${serviceName}.service`);
+          
+          if (require('node:fs').existsSync(serviceFile)) {
+            const serviceConfig = require('node:fs').readFileSync(serviceFile, 'utf8');
+            const statusOutput = execSync(`systemctl --user show "${serviceName}"`, { encoding: "utf-8" });
+            const config = parseServiceConfig(serviceConfig, statusOutput);
+            
+            const backupFile = join(backupDir, `${serviceName}.json`);
+            const backupData = {
+              name: serviceName,
+              file: extractFileFromConfig(serviceConfig),
+              port: config.port,
+              host: config.host,
+              env: config.env,
+              otel: config.otel,
+              prometheus: config.prometheus,
+              build: config.build,
+              https: config.https,
+              savedAt: new Date().toISOString(),
+              platform: platformInfo.platform
+            };
+            
+            require('node:fs').writeFileSync(backupFile, JSON.stringify(backupData, null, 2));
+            console.log(`  💾 Saved service: ${serviceName}`);
+          }
+        } catch (error) {
+          console.error(`  ⚠️  Failed to save service '${serviceName}': ${error}`);
+        }
+      }
+      
+    } else if (platformInfo.isMacOS) {
+      console.log("📝 To save all services on macOS, you need to manually backup the plist files from:");
+      console.log(`   ${platformInfo.serviceDir}/bs9.*.plist`);
+    } else if (platformInfo.isWindows) {
+      console.log("📝 To save all services on Windows, use PowerShell:");
+      console.log("   Get-Service -Name \"BS9_*\" | ForEach-Object { Export-ServiceConfiguration $_.Name }");
+    }
+    
+    console.log(`✅ All BS9 services save process completed`);
+  } catch (err) {
+    console.error(`❌ Failed to save all services: ${err}`);
+    if (!options.force) {
+      process.exit(1);
+    }
+  }
+}
+
+// Helper function to parse service configuration
+function parseServiceConfig(serviceConfig: string, statusOutput: string): any {
+  const config: any = {};
+  
+  // Extract port from service config
+  const portMatch = serviceConfig.match(/--port[=\s]+(\d+)/);
+  if (portMatch) {
+    config.port = parseInt(portMatch[1]);
+  }
+  
+  // Extract host from service config
+  const hostMatch = serviceConfig.match(/--host[=\s]+([^\s]+)/);
+  if (hostMatch) {
+    config.host = hostMatch[1];
+  }
+  
+  // Extract environment variables
+  const envMatches = serviceConfig.match(/--env[=\s]+([^\s]+)/g);
+  if (envMatches) {
+    config.env = envMatches.map((env: string) => env.replace(/--env[=\s]+/, ''));
+  }
+  
+  // Extract OpenTelemetry flag
+  config.otel = serviceConfig.includes('--otel') || serviceConfig.includes('--opentelemetry');
+  
+  // Extract Prometheus flag
+  config.prometheus = serviceConfig.includes('--prometheus');
+  
+  // Extract build flag
+  config.build = serviceConfig.includes('--build');
+  
+  // Extract HTTPS flag
+  config.https = serviceConfig.includes('--https');
+  
+  return config;
+}
+
+// Helper function to extract file path from service config
+function extractFileFromConfig(serviceConfig: string): string {
+  const execMatch = serviceConfig.match(/ExecStart=([^\n]+)/);
+  if (execMatch) {
+    const execLine = execMatch[1].trim();
+    // Extract the file path from the exec command
+    const fileMatch = execLine.match(/bun\s+([^\s]+)/);
+    if (fileMatch) {
+      return fileMatch[1];
+    }
+  }
+  return '';
+}