npm-killer 1.0.0

package/README.md

@@ -0,0 +1,97 @@
+# npm-killer
+
+Interactive CLI tool to find and kill Node.js processes running on ports. Unlike other port killers, this tool is designed to be **interactive and developer-friendly**.
+
+## Features
+
+- 🎯 **Interactive Mode** - Visual process selection with checkboxes
+- 🔍 **Smart Detection** - Finds only Node.js processes (node, npm, yarn, pnpm, bun)
+- 📋 **List Mode** - See all Node.js processes with their ports
+- ⚡ **Quick Kill** - Kill by port number or kill all at once
+- 🛡️ **Safe by Default** - Confirmation prompts before killing
+- 🎨 **Beautiful Output** - Color-coded, easy to read
+
+## Installation
+
+```bash
+npm install -g npm-killer
+```
+
+Or use with npx:
+```bash
+npx npm-killer
+```
+
+## Usage
+
+### Interactive Mode (Default)
+```bash
+npm-killer
+```
+Shows a checklist of all Node.js processes with open ports. Select multiple processes with spacebar, press Enter to confirm.
+
+### List Processes
+```bash
+npm-killer --list
+# or
+npm-killer -l
+```
+
+### Kill by Port
+```bash
+npm-killer --port 3000
+# or
+npm-killer -p 3000
+```
+
+### Kill All Node.js Processes
+```bash
+npm-killer --all
+# or
+npm-killer -a
+```
+
+### Force Kill (No Confirmation)
+```bash
+npm-killer --port 3000 --force
+npm-killer -p 3000 -f
+
+npm-killer --all --force
+npm-killer -a -f
+```
+
+## Example Output
+
+```
+$ npm-killer
+
+  Select processes to kill:
+
+  ✓ 1. node (PID: 12345) - Ports: 3000, 3001
+  ✓ 2. npm (PID: 12346) - Ports: 8080
+  ──────────────
+  ◯ Kill ALL Node.js processes
+  ◯ Exit without killing
+
+  Kill 2 process(es)? (y/N) y
+
+  ✓ Killed node (PID: 12345)
+  ✓ Killed npm (PID: 12346)
+```
+
+## Why npm-killer?
+
+Existing tools like `fuser`, `lsof`, or `kill-port` require you to know the port or PID upfront. `npm-killer` is built for developers who:
+- Run multiple Node.js services and forget which is on which port
+- Want a visual overview before killing anything
+- Prefer interactive selection over memorizing commands
+- Work with npm, yarn, pnpm, bun - all detected automatically
+
+## Requirements
+
+- Node.js 18+
+- macOS, Linux, or Windows (WSL)
+
+## License
+
+MIT

package/bin/index.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import { findNodeProcesses, killProcess, interactiveKill } from '../lib/port-killer.js';
+
+program
+  .name('npm-killer')
+  .description('Interactive CLI tool to kill Node.js processes on ports')
+  .version('1.0.0')
+  .option('-p, --port <port>', 'Kill process on specific port')
+  .option('-a, --all', 'Kill all Node.js processes')
+  .option('-l, --list', 'List all Node.js processes with ports')
+  .option('-f, --force', 'Force kill without confirmation')
+  .action(async (options) => {
+    try {
+      if (options.list) {
+        await listProcesses();
+        return;
+      }
+
+      if (options.port) {
+        await killByPort(options.port, options.force);
+        return;
+      }
+
+      if (options.all) {
+        await killAll(options.force);
+        return;
+      }
+
+      // Default: interactive mode
+      await interactiveMode();
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+async function listProcesses() {
+  const processes = await findNodeProcesses();
+  
+  if (processes.length === 0) {
+    console.log(chalk.yellow('No Node.js processes found with open ports.'));
+    return;
+  }
+
+  console.log(chalk.bold('\n  Node.js Processes with Open Ports:\n'));
+  
+  // Calculate column widths
+  const maxNameLen = Math.max(...processes.map(p => p.name.length), 4);
+  const maxPidLen = Math.max(...processes.map(p => String(p.pid).length), 3);
+  
+  // Header
+  console.log(`  ${chalk.cyan('#'.padEnd(3))} ${chalk.bold('Name'.padEnd(maxNameLen))}  ${chalk.bold('PID'.padStart(maxPidLen))}  ${chalk.bold('Ports')}  ${chalk.gray('Command')}`);
+  console.log(`  ${chalk.gray('─'.repeat(3))} ${chalk.gray('─'.repeat(maxNameLen))}  ${chalk.gray('─'.repeat(maxPidLen))}  ${chalk.gray('─────')}  ${chalk.gray('───────')}`);
+  
+  processes.forEach((proc, index) => {
+    const ports = proc.ports.length > 0 ? proc.ports.join(',') : '—';
+    // Truncate command to fit
+    const cmd = proc.cmd.length > 60 ? proc.cmd.substring(0, 57) + '...' : proc.cmd;
+    const name = proc.name.length > maxNameLen ? proc.name.substring(0, maxNameLen - 1) + '…' : proc.name.padEnd(maxNameLen);
+    console.log(`  ${chalk.cyan(String(index + 1).padEnd(3))} ${chalk.white(name)}  ${chalk.green(String(proc.pid).padStart(maxPidLen))}  ${chalk.yellow(ports.padEnd(5))}  ${chalk.gray(cmd)}`);
+  });
+  console.log();
+}
+
+async function killByPort(port, force) {
+  const processes = await findNodeProcesses();
+  const target = processes.find(p => p.ports.includes(parseInt(port)));
+  
+  if (!target) {
+    console.log(chalk.yellow(`No Node.js process found on port ${port}`));
+    return;
+  }
+
+  if (!force) {
+    const inquirer = (await import('inquirer')).default;
+    const answer = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Kill ${target.name} (PID: ${target.pid}) on port ${port}?`,
+      default: false
+    }]);
+    
+    if (!answer.confirm) {
+      console.log(chalk.gray('Cancelled.'));
+      return;
+    }
+  }
+
+  await killProcess(target.pid);
+  console.log(chalk.green(`✓ Killed ${target.name} (PID: ${target.pid}) on port ${port}`));
+}
+
+async function killAll(force) {
+  const processes = await findNodeProcesses();
+  
+  if (processes.length === 0) {
+    console.log(chalk.yellow('No Node.js processes found with open ports.'));
+    return;
+  }
+
+  if (!force) {
+    const inquirer = (await import('inquirer')).default;
+    const answer = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Kill all ${processes.length} Node.js process(es)?`,
+      default: false
+    }]);
+    
+    if (!answer.confirm) {
+      console.log(chalk.gray('Cancelled.'));
+      return;
+    }
+  }
+
+  for (const proc of processes) {
+    try {
+      await killProcess(proc.pid);
+      console.log(chalk.green(`✓ Killed ${proc.name} (PID: ${proc.pid})`));
+    } catch (error) {
+      console.error(chalk.red(`✗ Failed to kill ${proc.name} (PID: ${proc.pid}):`), error.message);
+    }
+  }
+}
+
+async function interactiveMode() {
+  await interactiveKill();
+}
+
+program.parse();

package/lib/port-killer.js

@@ -0,0 +1,166 @@
+import { execSync } from 'child_process';
+import psList from 'ps-list';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+export async function findNodeProcesses() {
+  const processes = await psList();
+  
+  const nodeProcesses = processes.filter(proc => {
+    const name = proc.name.toLowerCase();
+    const cmd = proc.cmd.toLowerCase();
+    return name === 'node' || 
+           name.includes('node') ||
+           name.includes('next-server') ||
+           cmd.includes('node') || 
+           cmd.includes('npm') ||
+           cmd.includes('yarn') ||
+           cmd.includes('pnpm') ||
+           cmd.includes('bun');
+  });
+
+  const processesWithPorts = [];
+  
+  for (const proc of nodeProcesses) {
+    const ports = await getProcessPorts(proc.pid);
+    if (ports.length > 0) {
+      processesWithPorts.push({
+        pid: proc.pid,
+        name: proc.name,
+        cmd: proc.cmd,
+        ports
+      });
+    }
+  }
+  
+  return processesWithPorts;
+}
+
+export async function getProcessPorts(pid) {
+  try {
+    const output = execSync(`lsof -i -P -p ${pid} 2>/dev/null`, { 
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    });
+    
+    const ports = [];
+    const lines = output.trim().split('\n');
+    const pidStr = String(pid);
+    
+    for (const line of lines) {
+      // Match lines where column 2 (PID) matches our target PID and it's LISTENing
+      // lsof format: COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 2 && parts[1] === pidStr) {
+        const match = line.match(/:(\d+)\s+\(LISTEN\)$/);
+        if (match) {
+          ports.push(parseInt(match[1]));
+        }
+      }
+    }
+    
+    return [...new Set(ports)];
+  } catch (error) {
+    return [];
+  }
+}
+
+export async function killProcess(pid, signal = 'SIGTERM') {
+  try {
+    process.kill(pid, signal);
+    
+    // Wait a bit and check if process is still alive
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    try {
+      process.kill(pid, 0); // Check if process exists
+      // If we get here, process still exists, force kill
+      if (signal !== 'SIGKILL') {
+        return killProcess(pid, 'SIGKILL');
+      }
+    } catch (e) {
+      // Process is dead, success
+      return true;
+    }
+  } catch (error) {
+    throw new Error(`Failed to kill process ${pid}: ${error.message}`);
+  }
+}
+
+export async function interactiveKill() {
+  const processes = await findNodeProcesses();
+  
+  if (processes.length === 0) {
+    console.log(chalk.yellow('\n  No Node.js processes found with open ports.\n'));
+    return;
+  }
+
+  console.log(chalk.bold('\n  Select processes to kill:\n'));
+  
+  const choices = processes.map((proc, index) => {
+    const ports = proc.ports.length > 0 ? proc.ports.join(', ') : 'none';
+    return {
+      name: `${chalk.cyan(index + 1)}. ${chalk.white(proc.name)} ${chalk.gray(`(PID: ${proc.pid})`)} - ${chalk.yellow('Ports:')} ${chalk.yellow(ports)}`,
+      value: proc,
+      short: `${proc.name} (${proc.pid})`
+    };
+  });
+  
+  choices.push(new inquirer.Separator());
+  choices.push({
+    name: chalk.red('Kill ALL Node.js processes'),
+    value: 'ALL'
+  });
+  choices.push({
+    name: chalk.gray('Exit without killing'),
+    value: 'EXIT'
+  });
+
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selected',
+      message: 'Use space to select, enter to confirm:',
+      choices,
+      validate: (answer) => {
+        if (answer.length === 0) {
+          return 'Select at least one process or choose Exit';
+        }
+        return true;
+      }
+    }
+  ]);
+
+  if (selected.includes('EXIT') || selected.length === 0) {
+    console.log(chalk.gray('\n  Cancelled.\n'));
+    return;
+  }
+
+  const toKill = selected.includes('ALL') ? processes : selected.filter(s => s !== 'ALL');
+  
+  // Final confirmation
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: `Kill ${toKill.length} process(es)?`,
+      default: false
+    }
+  ]);
+
+  if (!confirm) {
+    console.log(chalk.gray('\n  Cancelled.\n'));
+    return;
+  }
+
+  console.log('');
+  for (const proc of toKill) {
+    try {
+      await killProcess(proc.pid);
+      console.log(chalk.green(`  ✓ Killed ${proc.name} (PID: ${proc.pid})`));
+    } catch (error) {
+      console.error(chalk.red(`  ✗ Failed to kill ${proc.name} (PID: ${proc.pid}):`), error.message);
+    }
+  }
+  console.log('');
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "npm-killer",
+  "version": "1.0.0",
+  "description": "Interactive CLI tool to kill Node.js processes on ports",
+  "main": "bin/index.js",
+  "bin": {
+    "npm-killer": "bin/index.js"
+  },
+  "scripts": {
+    "start": "node bin/index.js",
+    "dev": "node bin/index.js",
+    "test": "node --test test/*.test.js",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "cli",
+    "port",
+    "kill",
+    "node",
+    "process",
+    "interactive"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.0",
+    "ps-list": "^8.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "type": "module"
+}

package/test/port-killer.test.js

@@ -0,0 +1,75 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { spawn } from 'child_process';
+import { findNodeProcesses, killProcess, getProcessPorts } from '../lib/port-killer.js';
+
+describe('port-killer', () => {
+  let testServer;
+  let testPort = 34567;
+  
+  before(async () => {
+    // Start a test HTTP server
+    testServer = spawn('node', ['-e', `
+      const http = require('http');
+      const server = http.createServer((req, res) => res.end('test'));
+      server.listen(${testPort}, () => console.log('Server started on port ${testPort}'));
+    `], { stdio: ['ignore', 'pipe', 'pipe'] });
+    
+    // Wait for server to start
+    await new Promise(resolve => setTimeout(resolve, 1500));
+  });
+  
+  after(async () => {
+    if (testServer) {
+      testServer.kill();
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+  });
+
+  it('should find Node.js processes with open ports', async () => {
+    const processes = await findNodeProcesses();
+    assert.ok(Array.isArray(processes));
+    
+    // Our test server should be in the list
+    const testProc = processes.find(p => p.ports.includes(testPort));
+    assert.ok(testProc, `Should find test process on port ${testPort}`);
+    assert.ok(testProc.pid > 0);
+    // Name might be 'node' or include 'node' 
+    assert.ok(testProc.name.toLowerCase() === 'node' || testProc.name.toLowerCase().includes('node'));
+  });
+
+  it('should get process ports correctly', async () => {
+    const processes = await findNodeProcesses();
+    const testProc = processes.find(p => p.ports.includes(testPort));
+    
+    if (testProc) {
+      const ports = await getProcessPorts(testProc.pid);
+      assert.ok(ports.includes(testPort));
+    }
+  });
+
+  it('should kill a process by PID', async () => {
+    // Start another test process to kill
+    const killServer = spawn('node', ['-e', `
+      const http = require('http');
+      const server = http.createServer((req, res) => res.end('test'));
+      server.listen(34568, () => console.log('Server started on port 34568'));
+    `], { stdio: ['ignore', 'pipe', 'pipe'] });
+    
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    
+    const processes = await findNodeProcesses();
+    const killProc = processes.find(p => p.ports.includes(34568));
+    
+    assert.ok(killProc, 'Should find process to kill');
+    
+    await killProcess(killProc.pid);
+    
+    // Verify it's dead
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    const processesAfter = await findNodeProcesses();
+    const deadProc = processesAfter.find(p => p.pid === killProc.pid);
+    assert.strictEqual(deadProc, undefined, 'Process should be dead');
+  });
+});