port-nuker 1.0.3 → 1.0.5

package/README.md

@@ -32,6 +32,9 @@ nuke <PORT>
 # Kill and wait until port is actually free
 nuke <PORT> --wait
 
+# Force kill even on protected ports
+nuke <PORT> --force
+
 # List all active ports and select one to kill interactively
 nuke list
 ```
@@ -87,6 +90,8 @@ nuke 5000 --wait && echo "Port is free!"
 ## Features
 
 - **Cross-Platform**: Works on Windows (using `netstat` + `taskkill`) and Unix-like systems (Linux/macOS using `lsof` + `kill`)
+- **Docker Awareness**: Detects when a port is held by Docker and offers to stop the specific container instead of killing the entire Docker daemon
+- **Safe Mode Protection**: Protected ports (22, 80, 443, 3306, 5432, 6379, 27017, 5000, 8080) require `--force` flag to prevent accidental termination of critical services
 - **Interactive Mode**: Browse all active ports with `nuke list` and select which one to kill
 - **Wait Mode**: Block until port is actually released with `--wait` flag for safe command chaining
 - **Detailed Process Info**: See PID, command name, user, memory usage, and protocol for each port
@@ -113,6 +118,49 @@ nuke 8080
 node server.js
 ```
 
+### Protected Ports (Safe Mode)
+
+```bash
+# Attempting to kill a protected port (e.g., SSH on 22)
+nuke 22
+# Output:
+# ⚠️  Port 22 is protected (SSH).
+#    This port is typically used for critical services.
+#    Use --force to override: nuke 22 --force
+
+# Force kill a protected port
+nuke 443 --force
+# Successfully nukes the process on port 443 (HTTPS)
+
+# Protected ports: 22 (SSH), 80 (HTTP), 443 (HTTPS), 3306 (MySQL),
+#                  5432 (PostgreSQL), 6379 (Redis), 27017 (MongoDB),
+#                  5000 (Flask/Docker), 8080 (Alt HTTP)
+```
+
+### Docker Containers
+
+```bash
+# When a port is held by Docker, port-nuker detects it automatically
+nuke 3000
+
+# Output:
+# 🐳 Detected Docker process (PID: 12345)
+#    Searching for container using this port...
+#
+# 📦 Found container using port 3000:
+#    Name: my-app
+#    ID: abc123def456
+#    Ports: 0.0.0.0:3000->3000/tcp
+#
+# What would you like to do?
+#   1. Stop container 'my-app' (recommended)
+#   2. ⚠️  Kill Docker daemon (stops ALL containers)
+#   3. Cancel
+
+# Selecting option 1 stops only the specific container
+# ✅ Successfully stopped container abc123def456
+```
+
 ## Requirements
 
 - Node.js >= 12.0.0

package/index.js

@@ -5,16 +5,34 @@ const os = require('os');
 const inquirer = require('inquirer');
 const Table = require('cli-table3');
 
+// Protected ports that require --force flag
+const SAFE_PORTS = [22, 80, 443, 3306, 5432, 6379, 27017, 5000, 8080];
+
+const SAFE_PORT_DESCRIPTIONS = {
+  22: 'SSH',
+  80: 'HTTP',
+  443: 'HTTPS',
+  3306: 'MySQL',
+  5432: 'PostgreSQL',
+  6379: 'Redis',
+  27017: 'MongoDB',
+  5000: 'Flask/Docker Registry',
+  8080: 'Alternative HTTP'
+};
+
 const args = process.argv.slice(2);
 
 // Parse arguments
 let port = null;
 let shouldWait = false;
+let shouldForce = false;
 let command = null;
 
 for (let i = 0; i < args.length; i++) {
   if (args[i] === '--wait') {
     shouldWait = true;
+  } else if (args[i] === '--force') {
+    shouldForce = true;
   } else if (args[i] === 'list') {
     command = 'list';
   } else if (!isNaN(args[i])) {
@@ -26,16 +44,179 @@ for (let i = 0; i < args.length; i++) {
 if (command === 'list') {
   listPorts();
 } else if (port) {
-  // nuke <PORT> [--wait]
-  nukePort(port, shouldWait);
+  // nuke <PORT> [--wait] [--force]
+  nukePort(port, shouldWait, shouldForce);
 } else {
   console.error('Usage:');
-  console.error('  nuke <PORT>           Kill process on specific port');
-  console.error('  nuke <PORT> --wait    Kill process and wait until port is free');
-  console.error('  nuke list             List all active ports and select one to kill');
+  console.error('  nuke <PORT>              Kill process on specific port');
+  console.error('  nuke <PORT> --wait       Kill process and wait until port is free');
+  console.error('  nuke <PORT> --force      Force kill even on protected ports');
+  console.error('  nuke list                List all active ports and select one to kill');
+  console.error('');
+  console.error('Protected ports (require --force): 22, 80, 443, 3306, 5432, 6379, 27017, 5000, 8080');
   process.exit(1);
 }
 
+// Check if a port is protected and requires --force flag
+function checkSafePort(port, force) {
+  const portNum = parseInt(port);
+  
+  if (SAFE_PORTS.includes(portNum) && !force) {
+    const description = SAFE_PORT_DESCRIPTIONS[portNum] || 'System Service';
+    console.error(`\n⚠️  Port ${port} is protected (${description}).`);
+    console.error(`   This port is typically used for critical services.`);
+    console.error(`   Use --force to override: nuke ${port} --force\n`);
+    return false;
+  }
+  
+  return true;
+}
+
+// Check if a process is Docker-related
+function isDockerProcess(commandName) {
+  if (!commandName) return false;
+  
+  const dockerProcessNames = [
+    'docker',
+    'dockerd',
+    'com.docker.backend',
+    'docker desktop',
+    'containerd',
+    'docker.exe'
+  ];
+  
+  const lowerCommand = commandName.toLowerCase();
+  return dockerProcessNames.some(name => lowerCommand.includes(name));
+}
+
+// Find Docker container using a specific port
+async function findDockerContainerByPort(port) {
+  return new Promise((resolve) => {
+    exec('docker ps --format "{{.ID}}|{{.Names}}|{{.Ports}}"', (error, stdout) => {
+      if (error) {
+        resolve(null);
+        return;
+      }
+
+      const lines = stdout.trim().split('\n');
+      
+      for (const line of lines) {
+        if (!line) continue;
+        
+        const [id, name, ports] = line.split('|');
+        
+        // Check if this container has the target port
+        // Formats: 0.0.0.0:3000->3000/tcp, :::3000->3000/tcp, etc.
+        const portRegex = new RegExp(`[:\\s]${port}->|[:\\s]${port}/`);
+        
+        if (ports && portRegex.test(ports)) {
+          resolve({ id, name, ports });
+          return;
+        }
+      }
+      
+      resolve(null);
+    });
+  });
+}
+
+// Handle Docker process - offer to stop container instead of killing daemon
+async function handleDockerProcess(port, pid, processCommand) {
+  console.log(`\n🐳 Detected Docker process (PID: ${pid})`);
+  console.log('   Searching for container using this port...\n');
+  
+  const container = await findDockerContainerByPort(port);
+  
+  if (!container) {
+    console.log('⚠️  Could not find a specific container using this port.');
+    console.log('   The port might be used by Docker\'s internal networking.\n');
+    
+    const answer = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: 'Cancel (recommended)', value: 'cancel' },
+          { name: '⚠️  Kill Docker daemon (stops ALL containers)', value: 'kill' }
+        ]
+      }
+    ]);
+    
+    if (answer.action === 'kill') {
+      const confirm = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          message: '⚠️  This will stop ALL Docker containers. Are you sure?',
+          default: false
+        }
+      ]);
+      
+      if (confirm.confirmed) {
+        killPid(pid);
+      } else {
+        console.log('Cancelled.');
+      }
+    } else {
+      console.log('Cancelled.');
+    }
+    return;
+  }
+  
+  // Found a container
+  console.log(`📦 Found container using port ${port}:`);
+  console.log(`   Name: ${container.name}`);
+  console.log(`   ID: ${container.id}`);
+  console.log(`   Ports: ${container.ports}\n`);
+  
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: `Stop container '${container.name}' (recommended)`, value: 'stop' },
+        { name: '⚠️  Kill Docker daemon (stops ALL containers)', value: 'kill' },
+        { name: 'Cancel', value: 'cancel' }
+      ]
+    }
+  ]);
+  
+  if (answer.action === 'stop') {
+    console.log(`\nStopping container '${container.name}'...`);
+    stopDockerContainer(container.id);
+  } else if (answer.action === 'kill') {
+    const confirm = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: '⚠️  This will stop ALL Docker containers. Are you sure?',
+        default: false
+      }
+    ]);
+    
+    if (confirm.confirmed) {
+      killPid(pid);
+    } else {
+      console.log('Cancelled.');
+    }
+  } else {
+    console.log('Cancelled.');
+  }
+}
+
+// Stop a Docker container
+function stopDockerContainer(containerId) {
+  exec(`docker stop ${containerId}`, (error, stdout, stderr) => {
+    if (error) {
+      console.error(`Failed to stop container: ${error.message}`);
+      return;
+    }
+    console.log(`✅ Successfully stopped container ${containerId}`);
+  });
+}
+
 // List all active ports with process details
 function listPorts() {
   const platform = os.platform();
@@ -235,11 +416,22 @@ async function promptKillProcess(processes) {
     if (answer.pid) {
       const selectedProcess = processes.find(p => p.pid === answer.pid);
       
+      // Check if port is protected
+      const portNum = parseInt(selectedProcess.port);
+      const isProtected = SAFE_PORTS.includes(portNum);
+      
+      let confirmMessage = `Kill process ${selectedProcess.command} (PID: ${answer.pid}) on port ${selectedProcess.port}?`;
+      
+      if (isProtected) {
+        const description = SAFE_PORT_DESCRIPTIONS[portNum] || 'System Service';
+        confirmMessage = `⚠️  Port ${selectedProcess.port} is protected (${description}).\n   Kill process ${selectedProcess.command} (PID: ${answer.pid})?`;
+      }
+      
       const confirm = await inquirer.prompt([
         {
           type: 'confirm',
           name: 'confirmed',
-          message: `Kill process ${selectedProcess.command} (PID: ${answer.pid}) on port ${selectedProcess.port}?`,
+          message: confirmMessage,
           default: false
         }
       ]);
@@ -335,7 +527,12 @@ function pollPortUntilFree(port, maxWaitSeconds = 30) {
 }
 
 // Original nuke port function
-function nukePort(port, shouldWait = false) {
+function nukePort(port, shouldWait = false, shouldForce = false) {
+  // Check if port is protected
+  if (!checkSafePort(port, shouldForce)) {
+    process.exit(1);
+  }
+  
   const platform = os.platform();
   let findCommand;
   
@@ -402,17 +599,76 @@ function nukePort(port, shouldWait = false) {
       return;
     }
 
-    pids.forEach(pid => {
-      console.log(`Found process with PID: ${pid}. Nuking it...`);
-      killPid(pid, () => {
-        if (shouldWait) {
-          // Wait a moment for the process to fully terminate
-          setTimeout(() => {
-            pollPortUntilFree(port);
-          }, 1000);
+    // Get process details to check for Docker
+    const pidArray = Array.from(pids);
+    
+    if (platform === 'win32') {
+      // Get process details on Windows
+      const tasklistCmd = `tasklist /FI "PID eq ${pidArray.join('" /FI "PID eq ')}" /FO CSV /NH`;
+      
+      exec(tasklistCmd, async (error, tasklistOutput) => {
+        let processCommand = null;
+        
+        if (!error && tasklistOutput) {
+          const lines = tasklistOutput.trim().split('\n');
+          if (lines.length > 0) {
+            const matches = lines[0].match(/"([^"]+)"/g);
+            if (matches && matches.length > 0) {
+              processCommand = matches[0].replace(/"/g, '');
+            }
+          }
+        }
+        
+        // Check if it's a Docker process
+        if (processCommand && isDockerProcess(processCommand)) {
+          await handleDockerProcess(port, pidArray[0], processCommand);
+        } else {
+          // Normal kill
+          pidArray.forEach(pid => {
+            console.log(`Found process with PID: ${pid}. Nuking it...`);
+            killPid(pid, () => {
+              if (shouldWait) {
+                setTimeout(() => {
+                  pollPortUntilFree(port);
+                }, 1000);
+              }
+            });
+          });
         }
       });
-    });
+    } else {
+      // Unix-like: use lsof to get process command
+      exec(`lsof -i :${port} -n -P`, async (error, lsofOutput) => {
+        let processCommand = null;
+        
+        if (!error && lsofOutput) {
+          const lines = lsofOutput.trim().split('\n');
+          if (lines.length > 1) {
+            const parts = lines[1].trim().split(/\s+/);
+            if (parts.length > 0) {
+              processCommand = parts[0];
+            }
+          }
+        }
+        
+        // Check if it's a Docker process
+        if (processCommand && isDockerProcess(processCommand)) {
+          await handleDockerProcess(port, pidArray[0], processCommand);
+        } else {
+          // Normal kill
+          pidArray.forEach(pid => {
+            console.log(`Found process with PID: ${pid}. Nuking it...`);
+            killPid(pid, () => {
+              if (shouldWait) {
+                setTimeout(() => {
+                  pollPortUntilFree(port);
+                }, 1000);
+              }
+            });
+          });
+        }
+      });
+    }
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "port-nuker",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "A simple CLI utility to kill processes holding a specific port. Solves EADDRINUSE errors instantly.",
   "main": "index.js",
   "bin": {