killportall 1.0.0

package/LICENSE

@@ -0,0 +1,23 @@
+SDODS License (Simple Do Or Don't Software License)
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+1. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+2. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+3. This license explicitly allows you to:
+   - Use the software for any purpose
+   - Modify the software
+   - Distribute the software
+   - Sublicense the software
+   - Sell the software
+
+4. This license explicitly prohibits you from:
+   - Holding the authors liable for damages
+   - Using the authors' names, trademarks, or logos without permission
+   - Claiming original authorship of the software
+
+If you do not agree to these terms, you must not use, modify, or distribute the software.

package/README.md

@@ -0,0 +1,205 @@
+# killportall
+
+A powerful cross-platform Node.js CLI tool for efficiently killing processes on specified ports with detailed logging and interactive mode.
+
+## Features
+
+- 🎯 Kill processes on single or multiple ports
+- 📊 Interactive mode to select ports from a list
+- 🔄 Configurable retry mechanism
+- 📝 Detailed process information display
+- ⚙️ Configuration file support
+- 🖥️ Cross-platform support (Windows, macOS, Linux)
+- 🎨 JSON output format for scripting
+- 🚀 Fast and efficient port killing
+
+## Installation
+
+```bash
+npm install -g killportall
+```
+
+## Usage
+
+### Basic Usage
+
+Kill a single port:
+```bash
+killportall 3000
+```
+
+Kill multiple ports:
+```bash
+killportall 3000 8080 5000
+```
+
+Kill a range of ports:
+```bash
+killportall 3000-3005
+```
+
+### Interactive Mode
+
+Run in interactive mode to select ports from a list:
+```bash
+killportall -i
+# or
+killportall --interactive
+```
+
+### Options
+
+- `-r, --retries <number>`: Number of retry attempts (default: 3)
+- `-t, --timeout <ms>`: Timeout between retries in milliseconds (default: 1000)
+- `-i, --interactive`: Run in interactive mode
+- `-j, --json`: Output results in JSON format
+- `--config <key=value>`: Set a configuration value
+- `-v, --version`: Display version number
+- `-h, --help`: Display help information
+
+### Configuration
+
+The tool supports configuration through a `.killportallrc.json` file in either the current directory or your home directory. Available configuration options:
+
+```json
+{
+  "retries": 3,
+  "timeout": 1000,
+  "interactive": false,
+  "outputFormat": "text"
+}
+```
+
+Set configuration values using the CLI:
+```bash
+killportall --config retries=5
+killportall --config timeout=2000
+killportall --config interactive=true
+killportall --config outputFormat=json
+```
+
+## Process Information
+
+Before killing a process, the tool displays detailed information:
+- Process ID (PID)
+- Process name/command
+- User (on Unix-like systems)
+- CPU usage
+- Memory usage
+
+## Output Formats
+
+### Text Output (Default)
+```
+✓ Port 3000: Process killed successfully
+✗ Port 8080: No process found
+```
+
+### JSON Output
+```json
+[
+  {
+    "port": 3000,
+    "success": true
+  },
+  {
+    "port": 8080,
+    "success": false,
+    "error": "No process found"
+  }
+]
+```
+
+## Error Handling
+
+The tool includes robust error handling:
+- Invalid port numbers
+- Permission issues
+- Process not found
+- Failed kill attempts
+
+## Debug Mode
+
+Enable debug logging:
+```bash
+DEBUG=killportall:* killportall 3000
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Publication Steps
+
+### For Maintainers
+
+1. Prepare for publication:
+```bash
+# Update version
+npm version patch  # or minor/major for bigger changes
+
+# Run tests
+npm test
+
+# Login to npm (if not already logged in)
+npm login
+```
+
+2. Test package locally:
+```bash
+# Link package locally
+npm link
+
+# Test CLI
+killportall --version
+killportall --help
+
+# Run some test commands
+killportall 3000
+killportall -i
+```
+
+3. Publish to npm:
+```bash
+# Publish main version
+npm publish
+
+# For beta releases
+npm publish --tag beta
+```
+
+4. Create GitHub Release:
+```bash
+# Create and push git tag
+git tag v1.0.0
+git push origin v1.0.0
+
+# Create release on GitHub with release notes
+```
+
+5. Post-publication verification:
+```bash
+# Unlink local version
+npm unlink killportall
+
+# Install from npm
+npm install -g killportall
+
+# Verify installation
+killportall --version
+```
+
+### Version Update Guidelines
+
+- MAJOR version (1.x.x): Breaking changes
+- MINOR version (x.1.x): New features, backward compatible
+- PATCH version (x.x.1): Bug fixes, backward compatible
+
+## License
+
+This project is licensed under the SDODS License - see the [LICENSE](LICENSE) file for details.
+
+## Badges
+
+[![npm version](https://badge.fury.io/js/killportall.svg)](https://badge.fury.io/js/killportall)
+[![License: SDODS](https://img.shields.io/badge/License-SDODS-blue.svg)](LICENSE)

package/bin/killportall.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import debug from 'debug';
+import { killPorts } from '../src/portKiller.js';
+import { validatePorts } from '../src/utils.js';
+import { runInteractiveMode } from '../src/interactive.js';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync } from 'fs';
+import { loadConfig, saveConfig } from '../src/config.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(readFileSync(join(__dirname, '..', 'package.json')));
+const debugLog = debug('killportall:cli');
+
+const program = new Command();
+const config = loadConfig();
+
+program
+  .version(packageJson.version)
+  .description('Kill processes running on specified ports')
+  .argument('[ports...]', 'Port numbers to kill (can be single port, range, or multiple ports)')
+  .option('-r, --retries <number>', 'Number of retry attempts', String(config.retries))
+  .option('-t, --timeout <ms>', 'Timeout between retries in milliseconds', String(config.timeout))
+  .option('-i, --interactive', 'Run in interactive mode to select ports from a list', config.interactive)
+  .option('-j, --json', 'Output results in JSON format')
+  .option('--config <key=value>', 'Set a configuration value (retries, timeout, interactive, outputFormat)')
+  .action(async (ports, options) => {
+    try {
+      // Handle config setting
+      if (options.config) {
+        const [key, value] = options.config.split('=');
+        if (!key || !value) {
+          console.error(chalk.red('Error: Invalid config format. Use key=value'));
+          process.exit(1);
+        }
+        const newConfig = {};
+        switch (key) {
+          case 'retries':
+            newConfig.retries = parseInt(value);
+            break;
+          case 'timeout':
+            newConfig.timeout = parseInt(value);
+            break;
+          case 'interactive':
+            newConfig.interactive = value === 'true';
+            break;
+          case 'outputFormat':
+            if (!['text', 'json'].includes(value)) {
+              console.error(chalk.red('Error: outputFormat must be either "text" or "json"'));
+              process.exit(1);
+            }
+            newConfig.outputFormat = value;
+            break;
+          default:
+            console.error(chalk.red(`Error: Unknown config key "${key}"`));
+            process.exit(1);
+        }
+        if (saveConfig({ ...config, ...newConfig })) {
+          console.log(chalk.green('Configuration saved successfully'));
+          process.exit(0);
+        } else {
+          process.exit(1);
+        }
+      }
+
+      debugLog('Starting port killing process with arguments:', { ports, options });
+      
+      const outputFormat = options.json ? 'json' : config.outputFormat;
+      let results;
+
+      if (options.interactive || config.interactive || ports.length === 0) {
+        results = await runInteractiveMode({
+          retries: parseInt(options.retries),
+          timeout: parseInt(options.timeout)
+        });
+      } else {
+        const validatedPorts = validatePorts(ports);
+        if (!validatedPorts.length) {
+          console.error(chalk.red('Error: No valid ports specified'));
+          process.exit(1);
+        }
+
+        results = await killPorts(validatedPorts, {
+          retries: parseInt(options.retries),
+          timeout: parseInt(options.timeout)
+        });
+      }
+
+      if (outputFormat === 'json') {
+        console.log(JSON.stringify(results, null, 2));
+      } else {
+        results.forEach(result => {
+          if (result.success) {
+            console.log(chalk.green(`✓ Port ${result.port}: Process killed successfully`));
+          } else {
+            console.error(chalk.red(`✗ Port ${result.port}: ${result.error}`));
+          }
+        });
+      }
+
+    } catch (error) {
+      console.error(chalk.red('Error:', error.message));
+      debugLog('Error details:', error);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "killportall",
+  "version": "1.0.0",
+  "description": "A cross-platform Node.js CLI tool for efficiently killing processes on specified ports",
+  "type": "module",
+  "main": "bin/killportall.js",
+  "bin": {
+    "killportall": "./bin/killportall.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --no-cache",
+    "start": "node bin/killportall.js",
+    "prepublishOnly": "npm test",
+    "postinstall": "chmod +x bin/killportall.js"
+  },
+  "keywords": [],
+  "author": "contact@yarlis.com>",
+  "license": "SDODS",
+  "bugs": {
+    "url": "https://github.com/yarlis/killportall/issues"
+  },
+  "homepage": "https://github.com/yarlis/killportall#readme",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "cross-spawn": "^7.0.3",
+    "debug": "^4.3.7",
+    "inquirer": "^12.0.1",
+    "jest": "^29.7.0"
+  }
+}

package/src/config.js

@@ -0,0 +1,69 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import { log } from './logger.js';
+
+const CONFIG_FILE_NAME = '.killportallrc.json';
+const DEFAULT_CONFIG = {
+  retries: 3,
+  timeout: 1000,
+  interactive: false,
+  outputFormat: 'text'
+};
+
+function getConfigPath() {
+  // First try current directory
+  const currentDirConfig = join(process.cwd(), CONFIG_FILE_NAME);
+  try {
+    readFileSync(currentDirConfig);
+    return currentDirConfig;
+  } catch (error) {
+    // If not found in current directory, use home directory
+    return join(homedir(), CONFIG_FILE_NAME);
+  }
+}
+
+function loadConfig() {
+  try {
+    const configPath = getConfigPath();
+    const configContent = readFileSync(configPath, 'utf8');
+    const config = JSON.parse(configContent);
+    
+    // Validate and merge with defaults
+    return {
+      ...DEFAULT_CONFIG,
+      ...config,
+      retries: Number(config.retries) || DEFAULT_CONFIG.retries,
+      timeout: Number(config.timeout) || DEFAULT_CONFIG.timeout,
+      interactive: Boolean(config.interactive),
+      outputFormat: ['text', 'json'].includes(config.outputFormat) 
+        ? config.outputFormat 
+        : DEFAULT_CONFIG.outputFormat
+    };
+  } catch (error) {
+    // If config file doesn't exist or is invalid, return defaults
+    return DEFAULT_CONFIG;
+  }
+}
+
+function saveConfig(config) {
+  try {
+    const configPath = getConfigPath();
+    const mergedConfig = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2));
+    return true;
+  } catch (error) {
+    log.error(`Failed to save config: ${error.message}`);
+    return false;
+  }
+}
+
+export {
+  loadConfig,
+  saveConfig,
+  DEFAULT_CONFIG
+};

package/src/constants.js

@@ -0,0 +1,32 @@
+export const COMMANDS = {
+  win32: {
+    find: {
+      command: 'netstat',
+      args: ['-ano', '|', 'findstr', ':']
+    },
+    kill: {
+      command: 'taskkill',
+      args: ['/F', '/PID']
+    }
+  },
+  darwin: {
+    find: {
+      command: 'lsof',
+      args: ['-i', ':']
+    },
+    kill: {
+      command: 'kill',
+      args: ['-9']
+    }
+  },
+  linux: {
+    find: {
+      command: 'lsof',
+      args: ['-i', ':']
+    },
+    kill: {
+      command: 'kill',
+      args: ['-9']
+    }
+  }
+};

package/src/interactive.js

@@ -0,0 +1,126 @@
+import inquirer from 'inquirer';
+import { log } from './logger.js';
+import { COMMANDS } from './constants.js';
+import crossSpawn from 'cross-spawn';
+import { killPorts, findProcessId, getProcessInfo } from './portKiller.js';
+import { isValidPort } from './utils.js';
+
+async function getAllActivePorts() {
+  return new Promise((resolve, reject) => {
+    const platform = process.platform;
+    let command, args;
+    
+    if (platform === 'win32') {
+      command = 'netstat';
+      args = ['-ano'];
+    } else {
+      command = 'lsof';
+      args = ['-i', '-n', '-P']; // Removed -t to get full output
+    }
+
+    const child = crossSpawn(command, args);
+    let output = '';
+
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        log.warn(`Command failed with code ${code}`);
+        return resolve([]);
+      }
+
+      const ports = new Set();
+      const lines = output.split('\n');
+
+      lines.forEach(line => {
+        const port = extractPortFromLine(line, platform);
+        if (port && isValidPort(port)) {
+          ports.add(port);
+        }
+      });
+
+      resolve(Array.from(ports).sort((a, b) => a - b));
+    });
+
+    child.on('error', (err) => {
+      reject(new Error(`Failed to list active ports: ${err.message}`));
+    });
+  });
+}
+
+function extractPortFromLine(line, platform) {
+  if (platform === 'win32') {
+    const match = line.match(/:(\d+)\s/);
+    return match ? parseInt(match[1]) : null;
+  } else {
+    // Enhanced regex for Unix-like systems to match both IPv4 and IPv6
+    const matches = line.match(/[.:]*:(\d+)\s+\(LISTEN\)/);
+    return matches ? parseInt(matches[1]) : null;
+  }
+}
+
+async function getPortWithProcessInfo(port) {
+  const pid = await findProcessId(port);
+  if (!pid) return { port, description: 'Unknown process' };
+
+  const processInfo = await getProcessInfo(pid, process.platform);
+  if (!processInfo) return { port, description: `PID: ${pid}` };
+
+  const description = processInfo.user
+    ? `${processInfo.name || processInfo.command} (PID: ${pid}, User: ${processInfo.user})`
+    : `${processInfo.name || processInfo.command} (PID: ${pid})`;
+
+  return { port, description };
+}
+
+async function runInteractiveMode(options) {
+  try {
+    log.info('Scanning for active ports...');
+    const activePorts = await getAllActivePorts();
+
+    if (activePorts.length === 0) {
+      log.info('No active ports found');
+      return [];
+    }
+
+    // Get process information for all ports
+    const portsWithInfo = await Promise.all(
+      activePorts.map(port => getPortWithProcessInfo(port))
+    );
+
+    const choices = portsWithInfo.map(({ port, description }) => ({
+      name: `Port ${port} - ${description}`,
+      value: port
+    }));
+
+    const { selectedPorts } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selectedPorts',
+        message: 'Select ports to kill (use space to select, enter to confirm):',
+        choices,
+        pageSize: 15,
+        validate: (answer) => {
+          if (answer.length === 0) {
+            return 'You must select at least one port';
+          }
+          return true;
+        }
+      }
+    ]);
+
+    if (selectedPorts.length === 0) {
+      log.warn('No ports selected');
+      return [];
+    }
+
+    return await killPorts(selectedPorts, options);
+  } catch (error) {
+    log.error(`Interactive mode failed: ${error.message}`);
+    throw error;
+  }
+}
+
+export { runInteractiveMode };

package/src/logger.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import debug from 'debug';
+
+const debugLog = debug('killportall:logger');
+
+class Logger {
+  info(message) {
+    console.log(chalk.blue('ℹ'), message);
+    debugLog('INFO:', message);
+  }
+
+  success(message) {
+    console.log(chalk.green('✓'), message);
+    debugLog('SUCCESS:', message);
+  }
+
+  warn(message) {
+    console.log(chalk.yellow('⚠'), message);
+    debugLog('WARN:', message);
+  }
+
+  error(message) {
+    console.error(chalk.red('✗'), message);
+    debugLog('ERROR:', message);
+  }
+}
+
+export const log = new Logger();

package/src/portKiller.js

@@ -0,0 +1,197 @@
+import crossSpawn from 'cross-spawn';
+import debug from 'debug';
+import { sleep } from './utils.js';
+import { COMMANDS } from './constants.js';
+import { log } from './logger.js';
+
+const debugLog = debug('killportall:killer');
+
+async function getProcessInfo(pid, platform) {
+  if (!pid) return null;
+  
+  let command, args;
+  if (platform === 'win32') {
+    command = 'tasklist';
+    args = ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'];
+  } else {
+    command = 'ps';
+    args = ['-p', pid, '-o', 'pid,ppid,user,%cpu,%mem,command'];
+  }
+
+  return new Promise((resolve) => {
+    const child = crossSpawn(command, args);
+    let output = '';
+
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) return resolve(null);
+      
+      const info = parseProcessInfo(output, platform);
+      debugLog(`Process info for PID ${pid}:`, info);
+      return resolve(info);
+    });
+
+    child.on('error', () => resolve(null));
+  });
+}
+
+function parseProcessInfo(output, platform) {
+  if (!output.trim()) return null;
+
+  if (platform === 'win32') {
+    // Windows CSV format: "Image Name","PID","Session Name","Session#","Mem Usage"
+    const [imageName, pid, , , memUsage] = output.trim()
+      .split(',')
+      .map(field => field.replace(/^"|"$/g, ''));
+    
+    return {
+      pid: parseInt(pid),
+      name: imageName,
+      memory: memUsage,
+      command: imageName
+    };
+  } else {
+    // Unix format: PID PPID USER %CPU %MEM COMMAND
+    const lines = output.trim().split('\n');
+    const processLine = lines.length > 1 ? lines[1] : lines[0]; // Skip header if present
+    const [pid, ppid, user, cpu, mem, ...commandParts] = processLine.trim().split(/\s+/);
+    return {
+      pid: parseInt(pid),
+      ppid: parseInt(ppid),
+      user,
+      cpu: parseFloat(cpu),
+      memory: parseFloat(mem),
+      command: commandParts.join(' ')
+    };
+  }
+}
+
+async function findProcessId(port) {
+  debugLog(`Finding process on port ${port}`);
+  
+  return new Promise((resolve, reject) => {
+    let command, args;
+    if (process.platform === 'win32') {
+      command = 'netstat';
+      args = ['-ano', '|', 'findstr', `:${port}`];
+    } else {
+      command = 'lsof';
+      args = ['-i', `:${port}`, '-t']; // -t to only get PID
+    }
+    
+    const child = crossSpawn(command, args);
+    let output = '';
+
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        debugLog('Command failed with code:', code);
+        return resolve(null);
+      }
+      
+      const pid = parsePidFromOutput(output, process.platform, port);
+      debugLog(`Found PID ${pid} for port ${port}`);
+      resolve(pid);
+    });
+
+    child.on('error', (err) => {
+      debugLog('Command error:', err);
+      reject(new Error(`Failed to execute find command: ${err.message}`));
+    });
+  });
+}
+
+function parsePidFromOutput(output, platform, port) {
+  if (!output.trim()) return null;
+  
+  if (platform === 'win32') {
+    // Look for exact port match in Windows netstat output
+    const regex = new RegExp(`[:\\s]${port}\\s+.*?\\s+(\\d+)\\s*$`, 'm');
+    const match = output.match(regex);
+    return match ? match[1] : null;
+  } else {
+    // For Unix-like systems, lsof -t returns only the PID
+    return output.trim().split('\n')[0];
+  }
+}
+
+async function killProcess(pid) {
+  debugLog(`Killing process ${pid}`);
+  const { command, args } = COMMANDS[process.platform].kill;
+  
+  return new Promise((resolve, reject) => {
+    const child = crossSpawn(command, [...args, pid]);
+    
+    child.on('close', (code) => {
+      resolve(code === 0);
+    });
+
+    child.on('error', (err) => {
+      reject(new Error(`Failed to kill process: ${err.message}`));
+    });
+  });
+}
+
+async function killPort(port, options = {}) {
+  const { retries = 3, timeout = 1000 } = options;
+  
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const pid = await findProcessId(port);
+      
+      if (!pid) {
+        log.info(`No process found on port ${port}`);
+        return { port, success: true };
+      }
+
+      // Get and display process information before killing
+      const processInfo = await getProcessInfo(pid, process.platform);
+      if (processInfo) {
+        log.info(`Process found on port ${port}:`);
+        log.info(`  PID: ${processInfo.pid}`);
+        log.info(`  Name: ${processInfo.name || processInfo.command}`);
+        if (processInfo.user) log.info(`  User: ${processInfo.user}`);
+        if (processInfo.cpu) log.info(`  CPU: ${processInfo.cpu}%`);
+        log.info(`  Memory: ${processInfo.memory}`);
+      }
+
+      const killed = await killProcess(pid);
+      if (killed) {
+        log.success(`Successfully killed process ${pid} on port ${port}`);
+        return { port, success: true };
+      }
+
+      if (attempt < retries) {
+        log.warn(`Failed to kill port ${port}, attempt ${attempt}/${retries}`);
+        await sleep(timeout);
+      }
+    } catch (error) {
+      debugLog(`Error killing port ${port}:`, error);
+      if (attempt === retries) {
+        return { port, success: false, error: error.message };
+      }
+      await sleep(timeout);
+    }
+  }
+
+  return { port, success: false, error: 'Max retries reached' };
+}
+
+async function killPorts(ports, options) {
+  debugLog(`Killing ports: ${ports.join(', ')}`);
+  return Promise.all(ports.map(port => killPort(port, options)));
+}
+
+export {
+  killPorts,
+  killPort,
+  findProcessId,
+  killProcess,
+  getProcessInfo
+};

package/src/utils.js

@@ -0,0 +1,40 @@
+import debug from 'debug';
+
+const debugLog = debug('killportall:utils');
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function validatePorts(ports) {
+  debugLog('Validating ports:', ports);
+  const validPorts = new Set();
+
+  ports.forEach(port => {
+    if (port.includes('-')) {
+      // Handle port ranges
+      const [start, end] = port.split('-').map(Number);
+      if (!isNaN(start) && !isNaN(end) && start <= end) {
+        for (let i = start; i <= end; i++) {
+          if (isValidPort(i)) validPorts.add(i);
+        }
+      }
+    } else {
+      // Handle single ports
+      const numPort = parseInt(port);
+      if (isValidPort(numPort)) validPorts.add(numPort);
+    }
+  });
+
+  return Array.from(validPorts);
+}
+
+function isValidPort(port) {
+  return Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+
+export {
+  sleep,
+  validatePorts,
+  isValidPort
+};