bs9 1.4.6 → 1.5.3

package/src/commands/stop.ts

@@ -12,6 +12,7 @@
 import { execSync } from "node:child_process";
 import { join } from "node:path";
 import { getPlatformInfo } from "../platform/detect.js";
+import { parseServiceArray, confirmAction } from "../utils/array-parser.js";
 
 // Security: Service name validation
 function isValidServiceName(name: string): boolean {
@@ -21,7 +22,57 @@ function isValidServiceName(name: string): boolean {
   return validPattern.test(name) && name.length <= 64 && !name.includes('..') && !name.includes('/');
 }
 
-export async function stopCommand(name: string): Promise<void> {
+export async function stopCommand(names: string[]): Promise<void> {
+  // Handle multiple arguments
+  const name = names.length > 0 ? names.join(' ') : '';
+  
+  // Handle multi-service operations
+  if (name.includes('[') || name === 'all') {
+    await handleMultiServiceStop(name);
+    return;
+  }
+  
+  // Single service operation (existing logic)
+  await handleSingleServiceStop(name);
+}
+
+async function handleMultiServiceStop(name: string): Promise<void> {
+  const services = await parseServiceArray(name);
+  
+  if (services.length === 0) {
+    console.log("❌ No services found matching the pattern");
+    return;
+  }
+  
+  // Safety confirmation for bulk operations
+  if (services.length > 1) {
+    console.log(`⚠️  About to stop ${services.length} services:`);
+    services.forEach(service => console.log(`   - ${service}`));
+    
+    const confirmed = await confirmAction('Are you sure? (y/N): ');
+    if (!confirmed) {
+      console.log('❌ Stop operation cancelled');
+      return;
+    }
+  }
+  
+  console.log(`🛑 Stopping ${services.length} services...`);
+  
+  const results = await Promise.allSettled(
+    services.map(async (serviceName) => {
+      try {
+        await handleSingleServiceStop(serviceName);
+        return { service: serviceName, status: 'success', error: null };
+      } catch (error) {
+        return { service: serviceName, status: 'failed', error: error instanceof Error ? error.message : String(error) };
+      }
+    })
+  );
+  
+  displayBatchResults(results, 'stop');
+}
+
+async function handleSingleServiceStop(name: string): Promise<void> {
   // Security: Validate service name
   if (!isValidServiceName(name)) {
     console.error(`❌ Security: Invalid service name: ${name}`);
@@ -48,3 +99,28 @@ export async function stopCommand(name: string): Promise<void> {
     process.exit(1);
   }
 }
+
+function displayBatchResults(results: PromiseSettledResult<{ service: string; status: string; error: string | null }>[], operation: string): void {
+  console.log(`\n📊 Batch ${operation} Results`);
+  console.log("=".repeat(50));
+  
+  const successful = results.filter(r => r.status === 'fulfilled' && r.value.status === 'success');
+  const failed = results.filter(r => r.status === 'fulfilled' && r.value.status === 'failed');
+  
+  successful.forEach(result => {
+    if (result.status === 'fulfilled') {
+      console.log(`✅ ${result.value.service} - ${operation} successful`);
+    }
+  });
+  
+  failed.forEach(result => {
+    if (result.status === 'fulfilled') {
+      console.log(`❌ ${result.value.service} - Failed: ${result.value.error}`);
+    }
+  });
+  
+  console.log(`\n📈 Summary:`);
+  console.log(`   Total: ${results.length} services`);
+  console.log(`   Success: ${successful.length}/${results.length} (${((successful.length / results.length) * 100).toFixed(1)}%)`);
+  console.log(`   Failed: ${failed.length}/${results.length} (${((failed.length / results.length) * 100).toFixed(1)}%)`);
+}

package/src/utils/array-parser.ts

@@ -0,0 +1,131 @@
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+
+export interface ServiceInfo {
+  name: string;
+  status: string;
+  pid?: number;
+  port?: number;
+}
+
+export async function parseServiceArray(input: string): Promise<string[]> {
+  if (!input) return [];
+  
+  // Handle "all" keyword
+  if (input === 'all') {
+    return await getAllServices();
+  }
+  
+  // Handle array syntax [app1, app2, app-*]
+  const arrayMatch = input.match(/^\[(.*)\]$/);
+  if (!arrayMatch) {
+    return [input]; // Single service
+  }
+  
+  const services = arrayMatch[1].split(',').map(s => s.trim());
+  const expanded: string[] = [];
+  
+  for (const service of services) {
+    if (service.includes('*')) {
+      // Pattern matching
+      const pattern = service.replace('*', '.*');
+      const matching = await getServicesByPattern(pattern);
+      expanded.push(...matching);
+    } else if (service === 'all') {
+      // All services
+      const allServices = await getAllServices();
+      expanded.push(...allServices);
+    } else {
+      // Specific service
+      expanded.push(service);
+    }
+  }
+  
+  // Remove duplicates and return
+  return [...new Set(expanded)];
+}
+
+export async function getAllServices(): Promise<string[]> {
+  try {
+    const output = execSync("systemctl --user list-units --type=service --all --no-pager --no-legend", { 
+      encoding: "utf-8" 
+    });
+    
+    const services = output
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => line.split(' ')[0])
+      .filter(service => service.includes('bs9-'))
+      .map(service => service.replace('bs9-', ''));
+    
+    return services;
+  } catch {
+    return [];
+  }
+}
+
+export async function getServicesByPattern(pattern: string): Promise<string[]> {
+  try {
+    const allServices = await getAllServices();
+    const regex = new RegExp(`^${pattern}$`);
+    return allServices.filter(service => regex.test(service));
+  } catch {
+    return [];
+  }
+}
+
+export async function getServiceInfo(serviceName: string): Promise<ServiceInfo | null> {
+  try {
+    const status = execSync(`systemctl --user is-active bs9-${serviceName}`, { encoding: "utf-8" }).trim();
+    const showOutput = execSync(`systemctl --user show bs9-${serviceName}`, { encoding: "utf-8" });
+    
+    const pidMatch = showOutput.match(/MainPID=(\d+)/);
+    const portMatch = showOutput.match(/Environment=PORT=(\d+)/);
+    
+    return {
+      name: serviceName,
+      status: status,
+      pid: pidMatch ? parseInt(pidMatch[1]) : undefined,
+      port: portMatch ? parseInt(portMatch[1]) : undefined
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function getMultipleServiceInfo(serviceNames: string[]): Promise<ServiceInfo[]> {
+  const results = await Promise.allSettled(
+    serviceNames.map(name => getServiceInfo(name))
+  );
+  
+  return results
+    .filter((result): result is PromiseFulfilledResult<ServiceInfo> => 
+      result.status === 'fulfilled' && result.value !== null
+    )
+    .map(result => result.value);
+}
+
+export function confirmAction(message: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    process.stdout.write(message);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    
+    const onData = (key: string) => {
+      if (key === 'y' || key === 'Y') {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.off('data', onData);
+        resolve(true);
+      } else if (key === '\n' || key === '\r' || key === 'n' || key === 'N') {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.off('data', onData);
+        resolve(false);
+      }
+    };
+    
+    process.stdin.on('data', onData);
+  });
+}