bs9 1.4.3 → 1.5.0

package/src/commands/start.ts

@@ -16,6 +16,7 @@ import { randomUUID } from "node:crypto";
 import { writeFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { getPlatformInfo } from "../platform/detect.js";
+import { parseServiceArray, getMultipleServiceInfo, confirmAction } from "../utils/array-parser.js";
 
 // Security: Host validation function
 function isValidHost(host: string): boolean {
@@ -60,7 +61,53 @@ interface StartOptions {
   https?: boolean;
 }
 
-export async function startCommand(file: string, options: StartOptions): Promise<void> {
+export async function startCommand(files: string[], options: StartOptions): Promise<void> {
+  const platformInfo = getPlatformInfo();
+  
+  // Handle multiple arguments
+  const file = files.length > 0 ? files.join(' ') : '';
+  
+  // Handle multi-service operations
+  if (file.includes('[') || file === 'all') {
+    await handleMultiServiceStart(file, options);
+    return;
+  }
+  
+  // Single service operation (existing logic)
+  await handleSingleServiceStart(file, options);
+}
+
+async function handleMultiServiceStart(file: string, options: StartOptions): Promise<void> {
+  const services = await parseServiceArray(file);
+  
+  if (services.length === 0) {
+    console.log("❌ No services found matching the pattern");
+    return;
+  }
+  
+  console.log(`🚀 Starting ${services.length} services...`);
+  
+  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}`);
+        }
+        
+        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) };
+      }
+    })
+  );
+  
+  displayBatchResults(results, 'start');
+}
+
+async function handleSingleServiceStart(file: string, options: StartOptions): Promise<void> {
   const platformInfo = getPlatformInfo();
   
   // Security: Validate and sanitize file path
@@ -166,6 +213,51 @@ export async function startCommand(file: string, options: StartOptions): Promise
   }
 }
 
+function findServiceFile(serviceName: string): string | null {
+  // Try to find the service file in common locations
+  const possiblePaths = [
+    join(process.cwd(), `${serviceName}.js`),
+    join(process.cwd(), `${serviceName}.ts`),
+    join(process.cwd(), 'src', `${serviceName}.js`),
+    join(process.cwd(), 'src', `${serviceName}.ts`),
+    join(process.cwd(), 'app', `${serviceName}.js`),
+    join(process.cwd(), 'app', `${serviceName}.ts`),
+  ];
+  
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  
+  return null;
+}
+
+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)}%)`);
+}
+
 async function createLinuxService(serviceName: string, execPath: string, host: string, port: string, protocol: string, options: StartOptions): Promise<void> {
   // Phase 1: Generate hardened systemd unit
   const unitContent = generateSystemdUnit({

package/src/commands/status.ts

@@ -13,6 +13,7 @@ import { execSync } from "node:child_process";
 import { join } from "node:path";
 import { getPlatformInfo } from "../platform/detect.js";
 import { readFileSync } from "node:fs";
+import { parseServiceArray, getMultipleServiceInfo } from "../utils/array-parser.js";
 
 interface StatusOptions {
   watch?: boolean;
@@ -34,7 +35,56 @@ interface ServiceStatus {
   lastRestart?: string;
 }
 
-export async function statusCommand(options: StatusOptions): Promise<void> {
+export async function statusCommand(options: StatusOptions, names?: string[]): Promise<void> {
+  const platformInfo = getPlatformInfo();
+  
+  // Handle multiple arguments
+  const name = names && names.length > 0 ? names.join(' ') : undefined;
+  
+  // Handle multi-service status
+  if (name && (name.includes('[') || name === 'all')) {
+    await handleMultiServiceStatus(name, options);
+    return;
+  }
+  
+  // Single service or all services status (existing logic)
+  await handleStatus(options, name);
+}
+
+async function handleMultiServiceStatus(name: string, options: StatusOptions): Promise<void> {
+  const services = await parseServiceArray(name);
+  
+  if (services.length === 0) {
+    console.log("❌ No services found matching the pattern");
+    return;
+  }
+  
+  console.log(`📊 Multi-Service Status: ${name}`);
+  console.log("=".repeat(80));
+  
+  const serviceInfo = await getMultipleServiceInfo(services);
+  
+  if (serviceInfo.length === 0) {
+    console.log("❌ No running services found");
+    return;
+  }
+  
+  displayMultiServiceStatus(serviceInfo, name);
+  
+  if (options.watch) {
+    console.log("\n🔄 Watching for changes (Ctrl+C to stop)...");
+    setInterval(async () => {
+      console.clear();
+      console.log(`📊 Multi-Service Status: ${name}`);
+      console.log("=".repeat(80));
+      
+      const updatedServiceInfo = await getMultipleServiceInfo(services);
+      displayMultiServiceStatus(updatedServiceInfo, name);
+    }, 2000);
+  }
+}
+
+async function handleStatus(options: StatusOptions, name?: string): Promise<void> {
   const platformInfo = getPlatformInfo();
   
   try {
@@ -48,6 +98,11 @@ export async function statusCommand(options: StatusOptions): Promise<void> {
       services = await getWindowsServices();
     }
     
+    // Filter by specific service if provided
+    if (name) {
+      services = services.filter(service => service.name === name);
+    }
+    
     displayServices(services);
     
     if (options.watch) {
@@ -66,15 +121,120 @@ export async function statusCommand(options: StatusOptions): Promise<void> {
           updatedServices = await getWindowsServices();
         }
         
+        // Filter by specific service if provided
+        if (name) {
+          updatedServices = updatedServices.filter(service => service.name === name);
+        }
+        
         displayServices(updatedServices);
       }, 2000);
     }
-  } catch (err) {
-    console.error("❌ Failed to get service status:", err);
+  } catch (error) {
+    console.error("❌ Failed to get service status:", error);
     process.exit(1);
   }
 }
 
+function displayServices(services: ServiceStatus[]): void {
+  if (services.length === 0) {
+    console.log("📋 No BS9 services found");
+    console.log("💡 Use 'bs9 start <file>' or 'bs9 deploy <file>' to create a service");
+    return;
+  }
+
+  // Header with better formatting
+  console.log(`${"SERVICE".padEnd(18)} ${"STATUS".padEnd(15)} ${"CPU".padEnd(10)} ${"MEMORY".padEnd(12)} ${"UPTIME".padEnd(12)} ${"TASKS".padEnd(8)} DESCRIPTION`);
+  console.log("─".repeat(100));
+  
+  // Sort services by status (running first, then by name)
+  const sortedServices = services.sort((a, b) => {
+    const aRunning = a.active === "active" && a.sub === "running";
+    const bRunning = b.active === "active" && a.sub === "running";
+    if (aRunning !== bRunning) return bRunning ? 1 : -1;
+    return a.name.localeCompare(b.name);
+  });
+
+  for (const svc of sortedServices) {
+    // Better status formatting with indicators
+    let statusIndicator = "";
+    let status = `${svc.active}/${svc.sub}`;
+    
+    if (svc.active === "active" && svc.sub === "running") {
+      statusIndicator = "✅";
+      status = "running";
+    } else if (svc.active === "activating" && svc.sub.includes("auto-restart")) {
+      statusIndicator = "🔄";
+      status = "restarting";
+    } else if (svc.active === "failed" || svc.sub === "failed") {
+      statusIndicator = "❌";
+      status = "failed";
+    } else if (svc.active === "inactive") {
+      statusIndicator = "⏸️";
+      status = "stopped";
+    } else {
+      statusIndicator = "⚠️";
+    }
+
+    const displayStatus = `${statusIndicator} ${status}`;
+    
+    // Format memory and uptime better
+    const formattedMemory = svc.memory ? formatMemory(parseMemory(svc.memory)) : "-";
+    const formattedUptime = svc.uptime || "-";
+    const formattedCPU = svc.cpu || "-";
+    
+    console.log(
+      `${svc.name.padEnd(18)} ${displayStatus.padEnd(15)} ${formattedCPU.padEnd(10)} ${formattedMemory.padEnd(12)} ${formattedUptime.padEnd(12)} ${(svc.tasks || "-").padEnd(8)} ${svc.description}`
+    );
+  }
+  
+  // Enhanced summary with better formatting
+  console.log("\n📊 Service Summary:");
+  const totalServices = services.length;
+  const runningServices = services.filter(s => s.active === "active" && s.sub === "running").length;
+  const failedServices = services.filter(s => s.active === "failed" || s.sub === "failed").length;
+  const restartingServices = services.filter(s => s.active === "activating" && s.sub.includes("auto-restart")).length;
+  const totalMemory = services.reduce((sum, s) => sum + (s.memory ? parseMemory(s.memory) : 0), 0);
+  
+  console.log(`  📈 Status: ${runningServices} running, ${failedServices} failed, ${restartingServices} restarting`);
+  console.log(`  📦 Total: ${runningServices}/${totalServices} services running`);
+  console.log(`  💾 Memory: ${formatMemory(totalMemory)}`);
+  console.log(`  🕒 Last updated: ${new Date().toLocaleString()}`);
+
+  // Show failed services details with better formatting
+  if (failedServices > 0) {
+    console.log("\n🚨 Failed Services:");
+    console.log("-".repeat(80));
+    
+    services.filter(s => s.active === "failed" || s.sub === "failed").forEach(svc => {
+      console.log(`  ❌ ${svc.name} - ${svc.description}`);
+    });
+  }
+}
+
+function displayMultiServiceStatus(serviceInfo: any[], pattern: string): void {
+  const running = serviceInfo.filter(s => s.status === 'active');
+  const failed = serviceInfo.filter(s => s.status === 'failed');
+  const inactive = serviceInfo.filter(s => s.status === 'inactive');
+  
+  console.log(`\n📊 Services matching pattern: ${pattern}`);
+  console.log(`   Total: ${serviceInfo.length} services`);
+  console.log(`   Running: ${running.length}/${serviceInfo.length} (${((running.length / serviceInfo.length) * 100).toFixed(1)}%)`);
+  console.log(`   Failed: ${failed.length}/${serviceInfo.length} (${((failed.length / serviceInfo.length) * 100).toFixed(1)}%)`);
+  console.log(`   Inactive: ${inactive.length}/${serviceInfo.length} (${((inactive.length / serviceInfo.length) * 100).toFixed(1)}%)`);
+  
+  if (serviceInfo.length > 0) {
+    console.log("\n📋 Service Details:");
+    console.log("-".repeat(80));
+    
+    serviceInfo.forEach(service => {
+      const statusIcon = service.status === 'active' ? '✅' : 
+                        service.status === 'failed' ? '❌' : '⏸️';
+      
+      console.log(`${statusIcon} ${service.name.padEnd(20)} PID: ${service.pid?.toString().padStart(8) || '-'.padStart(8)} PORT: ${service.port?.toString().padStart(6) || '-'.padStart(6)} STATUS: ${service.status.padEnd(10)}`);
+    });
+  }
+}
+
 async function getLinuxServices(): Promise<ServiceStatus[]> {
   const services: ServiceStatus[] = [];
   const platformInfo = getPlatformInfo();
@@ -208,113 +368,6 @@ async function getWindowsServices(): Promise<ServiceStatus[]> {
   return services;
 }
 
-function displayServices(services: ServiceStatus[]): void {
-  if (services.length === 0) {
-    console.log("📋 No BS9 services found");
-    console.log("💡 Use 'bs9 start <file>' or 'bs9 deploy <file>' to create a service");
-    return;
-  }
-
-  // Header with better formatting
-  console.log(`${"SERVICE".padEnd(18)} ${"STATUS".padEnd(15)} ${"CPU".padEnd(10)} ${"MEMORY".padEnd(12)} ${"UPTIME".padEnd(12)} ${"TASKS".padEnd(8)} DESCRIPTION`);
-  console.log("─".repeat(100));
-  
-  // Sort services by status (running first, then by name)
-  const sortedServices = services.sort((a, b) => {
-    const aRunning = a.active === "active" && a.sub === "running";
-    const bRunning = b.active === "active" && b.sub === "running";
-    if (aRunning !== bRunning) return bRunning ? 1 : -1;
-    return a.name.localeCompare(b.name);
-  });
-
-  for (const svc of sortedServices) {
-    // Better status formatting with indicators
-    let statusIndicator = "";
-    let status = `${svc.active}/${svc.sub}`;
-    
-    if (svc.active === "active" && svc.sub === "running") {
-      statusIndicator = "✅";
-      status = "running";
-    } else if (svc.active === "activating" && svc.sub.includes("auto-restart")) {
-      statusIndicator = "🔄";
-      status = "restarting";
-    } else if (svc.active === "failed" || svc.sub === "failed") {
-      statusIndicator = "❌";
-      status = "failed";
-    } else if (svc.active === "inactive") {
-      statusIndicator = "⏸️";
-      status = "stopped";
-    } else {
-      statusIndicator = "⚠️";
-    }
-
-    const displayStatus = `${statusIndicator} ${status}`;
-    
-    // Format memory and uptime better
-    const formattedMemory = svc.memory ? formatMemory(parseMemory(svc.memory)) : "-";
-    const formattedUptime = svc.uptime || "-";
-    const formattedCPU = svc.cpu || "-";
-    
-    console.log(
-      `${svc.name.padEnd(18)} ${displayStatus.padEnd(15)} ${formattedCPU.padEnd(10)} ${formattedMemory.padEnd(12)} ${formattedUptime.padEnd(12)} ${(svc.tasks || "-").padEnd(8)} ${svc.description}`
-    );
-  }
-  
-  // Enhanced summary with better formatting
-  console.log("\n📊 Service Summary:");
-  const totalServices = services.length;
-  const runningServices = services.filter(s => s.active === "active" && s.sub === "running").length;
-  const failedServices = services.filter(s => s.active === "failed" || s.sub === "failed").length;
-  const restartingServices = services.filter(s => s.active === "activating" && s.sub.includes("auto-restart")).length;
-  const totalMemory = services.reduce((sum, s) => sum + (s.memory ? parseMemory(s.memory) : 0), 0);
-  
-  console.log(`  📈 Status: ${runningServices} running, ${failedServices} failed, ${restartingServices} restarting`);
-  console.log(`  📦 Total: ${runningServices}/${totalServices} services running`);
-  console.log(`  💾 Memory: ${formatMemory(totalMemory)}`);
-  console.log(`  🕒 Last updated: ${new Date().toLocaleString()}`);
-
-  // Show failed services details with better formatting
-  if (failedServices > 0) {
-    console.log("\n❌ Failed Services:");
-    const failed = services.filter(s => s.active === "failed" || s.sub === "failed");
-    for (const svc of failed) {
-      console.log(`  • ${svc.name}: ${svc.active}/${svc.sub}`);
-      console.log(`    💡 Troubleshoot: bs9 logs ${svc.name} --tail 20`);
-      console.log(`    💡 Check: bs9 status ${svc.name}`);
-    }
-  }
-
-  // Show restarting services details
-  if (restartingServices > 0) {
-    console.log("\n🔄 Restarting Services:");
-    const restarting = services.filter(s => s.active === "activating" && s.sub.includes("auto-restart"));
-    for (const svc of restarting) {
-      console.log(`  • ${svc.name}: ${svc.active}/${svc.sub}`);
-      if (svc.exitCode) {
-        console.log(`    ❌ Exit Code: ${svc.exitCode}`);
-      }
-      if (svc.lastRestart) {
-        console.log(`    🕒 Last Restart: ${svc.lastRestart}`);
-      }
-      console.log(`    💡 Troubleshoot: bs9 logs ${svc.name} --tail 20`);
-      console.log(`    💡 Check: bs9 status ${svc.name}`);
-    }
-  }
-
-  // Show running services details
-  if (runningServices > 0) {
-    console.log("\n✅ Running Services:");
-    const running = services.filter(s => s.active === "active" && s.sub === "running");
-    for (const svc of running) {
-      const memory = svc.memory ? formatMemory(parseMemory(svc.memory)) : "N/A";
-      const uptime = svc.uptime || "N/A";
-      const port = svc.port || "3000";
-      console.log(`  • ${svc.name}: ${memory} memory, ${uptime} uptime`);
-      console.log(`    🌐 Access: http://localhost:${port}`);
-    }
-  }
-}
-
 function formatCPU(nsec: number): string {
   const ms = nsec / 1_000_000;
   return `${ms.toFixed(1)}ms`;

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);
+  });
+}