bs9 1.5.5 → 1.5.8

package/package.json

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

package/src/commands/start.ts

@@ -90,16 +90,27 @@ async function handleMultiServiceStart(file: string, options: StartOptions): Pro
   const results = await Promise.allSettled(
     services.map(async (serviceName) => {
       try {
-        // For multi-service, we need to find the service file
-        const serviceFile = findServiceFile(serviceName);
-        if (!serviceFile) {
-          throw new Error(`Service file not found for: ${serviceName}`);
-        }
+        const platformInfo = getPlatformInfo();
+        
+        // First check if service already exists
+        const serviceExists = await checkServiceExists(serviceName, platformInfo);
         
-        await handleSingleServiceStart(serviceFile, { ...options, name: serviceName });
-        return { service: serviceName, status: 'success', error: null };
+        if (serviceExists) {
+          // Service exists, start it directly
+          await startExistingService(serviceName, platformInfo);
+          return { service: serviceName, status: 'success', error: null };
+        } else {
+          // Service doesn't exist, look for file
+          const serviceFile = findServiceFile(serviceName);
+          if (!serviceFile) {
+            throw new Error(`Service file not found for: ${serviceName}`);
+          }
+          
+          await handleSingleServiceStart(serviceFile, { ...options, name: serviceName });
+          return { service: serviceName, status: 'success', error: null };
+        }
       } catch (error) {
-        return { service: serviceName, status: 'failed', error: error instanceof Error ? error.message : String(error) };
+        return { service: serviceName, status: 'failed', error: (error as Error).message };
       }
     })
   );
@@ -110,6 +121,22 @@ async function handleMultiServiceStart(file: string, options: StartOptions): Pro
 async function handleSingleServiceStart(file: string, options: StartOptions): Promise<void> {
   const platformInfo = getPlatformInfo();
   
+  // First, try to start existing service without file
+  const serviceName = options.name || file;
+  
+  const serviceExists = await checkServiceExists(serviceName, platformInfo);
+  
+  if (serviceExists) {
+    console.log(`📋 Service '${serviceName}' already exists, starting...`);
+    try {
+      await startExistingService(serviceName, platformInfo);
+      return;
+    } catch (error) {
+      console.log(`⚠️  Failed to start existing service: ${error}`);
+      console.log(`📁 Looking for application file: ${file}`);
+    }
+  }
+  
   // Security: Validate and sanitize file path
   const fullPath = resolve(file);
   if (!existsSync(fullPath)) {
@@ -127,7 +154,7 @@ async function handleSingleServiceStart(file: string, options: StartOptions): Pr
   
   // Security: Validate and sanitize service name
   const rawServiceName = options.name || basename(fullPath, fullPath.endsWith('.ts') ? '.ts' : '.js');
-  const serviceName = rawServiceName.replace(/[^a-zA-Z0-9-_]/g, "_").replace(/^[^a-zA-Z]/, "_").substring(0, 64);
+  const finalServiceName = rawServiceName.replace(/[^a-zA-Z0-9-_]/g, "_").replace(/^[^a-zA-Z]/, "_").substring(0, 64);
   
   // Security: Validate port number
   const port = options.port || "3000";
@@ -170,7 +197,7 @@ async function handleSingleServiceStart(file: string, options: StartOptions): Pr
       const buildDir = join(dirname(fullPath), ".bs9-build");
       mkdirSync(buildDir, { recursive: true });
       
-      const outputFile = join(buildDir, `${serviceName}.js`);
+      const outputFile = join(buildDir, `${finalServiceName}.js`);
       try {
         execSync(`bun build ${fullPath} --outdir ${buildDir} --target bun --minify --splitting`, { stdio: "inherit" });
         execPath = outputFile;
@@ -202,17 +229,61 @@ async function handleSingleServiceStart(file: string, options: StartOptions): Pr
 
   // Platform-specific service creation
   if (platformInfo.isLinux) {
-    await createLinuxService(serviceName, execPath, host, port, protocol, options);
+    await createLinuxService(finalServiceName, execPath, host, port, protocol, options);
   } else if (platformInfo.isMacOS) {
-    await createMacOSService(serviceName, execPath, host, port, protocol, options);
+    await createMacOSService(finalServiceName, execPath, host, port, protocol, options);
   } else if (platformInfo.isWindows) {
-    await createWindowsService(serviceName, execPath, host, port, protocol, options);
+    await createWindowsService(finalServiceName, execPath, host, port, protocol, options);
   } else {
     console.error(`❌ Platform ${platformInfo.platform} is not supported`);
     process.exit(1);
   }
 }
 
+async function checkServiceExists(serviceName: string, platformInfo: any): Promise<boolean> {
+  try {
+    if (platformInfo.isLinux) {
+      // Check if service exists in systemctl list-units
+      const listOutput = execSync("systemctl --user list-units --type=service --all --no-pager --no-legend", { encoding: "utf-8" });
+      const serviceExists = listOutput.includes(`${serviceName}.service`);
+      return serviceExists;
+    } else if (platformInfo.isMacOS) {
+      // Check if launchd service exists
+      const servicePath = join(platformInfo.serviceDir, `bs9.${serviceName}.plist`);
+      return existsSync(servicePath);
+    } else if (platformInfo.isWindows) {
+      // Check if Windows service exists
+      const { windowsCommand } = await import("../windows/service.js");
+      try {
+        await windowsCommand('show', { name: `BS9_${serviceName}` });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+async function startExistingService(serviceName: string, platformInfo: any): Promise<void> {
+  try {
+    if (platformInfo.isLinux) {
+      execSync(`systemctl --user start ${serviceName}`, { stdio: "inherit" });
+    } else if (platformInfo.isMacOS) {
+      const { launchdCommand } = await import("../macos/launchd.js");
+      await launchdCommand('start', { name: `bs9.${serviceName}` });
+    } else if (platformInfo.isWindows) {
+      const { windowsCommand } = await import("../windows/service.js");
+      await windowsCommand('start', { name: `BS9_${serviceName}` });
+    }
+    console.log(`🚀 Service '${serviceName}' started successfully`);
+  } catch (error) {
+    throw error;
+  }
+}
+
 function findServiceFile(serviceName: string): string | null {
   // Try to find the service file in common locations
   const possiblePaths = [
@@ -281,11 +352,21 @@ async function createLinuxService(serviceName: string, execPath: string, host: s
   }
   
   try {
-    writeFileSync(unitPath, unitContent);
-    console.log(`✅ Systemd user unit written to: ${unitPath}`);
+    // Check if service already exists
+    const serviceExists = existsSync(unitPath);
+    
+    if (!serviceExists) {
+      // First time: Create service file
+      writeFileSync(unitPath, unitContent);
+      console.log(`✅ Systemd user unit written to: ${unitPath}`);
+      execSync("systemctl --user daemon-reload");
+      execSync(`systemctl --user enable ${serviceName}`);
+      console.log(`🔧 Service '${serviceName}' created and enabled`);
+    } else {
+      console.log(`📋 Service '${serviceName}' already exists, starting...`);
+    }
     
-    execSync("systemctl --user daemon-reload");
-    execSync(`systemctl --user enable ${serviceName}`);
+    // Always start the service
     execSync(`systemctl --user start ${serviceName}`);
     
     console.log(`🚀 Service '${serviceName}' started successfully`);

package/src/utils/array-parser.ts

@@ -47,16 +47,20 @@ export async function parseServiceArray(input: string): Promise<string[]> {
 
 export async function getAllServices(): Promise<string[]> {
   try {
-    const output = execSync("systemctl --user list-units --type=service --all --no-pager --no-legend", { 
-      encoding: "utf-8" 
-    });
+    // Use the same logic as the status command since it already works
+    const output = execSync("systemctl --user list-units --type=service --all --no-pager --no-legend", { encoding: "utf-8" });
+    const lines = output.split("\n").filter(line => line.includes(".service"));
     
-    const services = output
-      .split('\n')
-      .filter(line => line.trim())
-      .map(line => line.split(' ')[0])
-      .filter(service => service.includes('bs9-'))
-      .map(service => service.replace('bs9-', ''));
+    const services = [];
+    for (const line of lines) {
+      const match = line.match(/^(?:\s*([●\s○]))?\s*([^\s]+)\.service\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)\s+(.+)$/);
+      if (match) {
+        const [, , name, , , , description] = match;
+        if (description.includes("BS9 Service:")) {
+          services.push(name);
+        }
+      }
+    }
     
     return services;
   } catch {
@@ -67,7 +71,9 @@ export async function getAllServices(): Promise<string[]> {
 export async function getServicesByPattern(pattern: string): Promise<string[]> {
   try {
     const allServices = await getAllServices();
-    const regex = new RegExp(`^${pattern}$`);
+    // Convert glob pattern to regex
+    const regexPattern = pattern.replace(/\*/g, '.*');
+    const regex = new RegExp(`^${regexPattern}$`);
     return allServices.filter(service => regex.test(service));
   } catch {
     return [];