port-nuker 1.0.4 → 1.0.5

package/README.md

@@ -90,6 +90,7 @@ 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
@@ -136,6 +137,30 @@ nuke 443 --force
 #                  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

@@ -72,6 +72,151 @@ function checkSafePort(port, force) {
   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();
@@ -454,17 +599,76 @@ function nukePort(port, shouldWait = false, shouldForce = 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.4",
+  "version": "1.0.5",
   "description": "A simple CLI utility to kill processes holding a specific port. Solves EADDRINUSE errors instantly.",
   "main": "index.js",
   "bin": {