kport 1.0.0__py3-none-any.whl

kport-1.0.0.dist-info/METADATA

@@ -0,0 +1,361 @@
+Metadata-Version: 2.4
+Name: kport
+Version: 1.0.0
+Summary: A cross-platform command-line tool to inspect and kill processes using specific ports
+Home-page: https://github.com/farman20ali/port-killer
+Author: Farman Ali (Alien)
+Author-email: farman20ali@example.com
+Project-URL: Bug Reports, https://github.com/farman20ali/port-killer/issues
+Project-URL: Source, https://github.com/farman20ali/port-killer
+Keywords: port,kill,process,network,cross-platform,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: System :: Systems Administration
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# 🔪 kport - Cross-Platform Port Inspector and Killer
+
+A simple, powerful command-line tool to inspect and kill processes using specific ports on Windows, Linux, and macOS.
+
+## ✨ Features
+
+- 🔍 **Inspect ports** - Find which process is using a specific port
+- 🔎 **Inspect by process name** - Find all processes matching a name and their ports
+- 🔪 **Kill processes** - Terminate processes using specific ports
+- 📋 **List all ports** - View all listening ports and their processes
+- 🎯 **Kill by process name** - Kill all processes matching a name (e.g., "node", "python")
+- 🔥 **Kill multiple ports** - Kill processes on multiple ports at once
+- 🎨 **Colorized output** - Easy-to-read colored terminal output
+- ✅ **Confirmation prompts** - Safety confirmation before killing processes
+- 🌍 **Cross-platform** - Works on Windows, Linux, and macOS
+- 🚀 **Easy to use** - Simple command-line interface
+
+## 📦 Installation
+
+### Quick Install (Once Published to PyPI)
+
+```bash
+pip install kport
+```
+
+### Install from GitHub
+
+```bash
+pip install git+https://github.com/farman20ali/port-killer.git
+```
+
+### Install from Source
+
+```bash
+# Clone the repository
+git clone https://github.com/farman20ali/port-killer.git
+cd port-killer
+
+# Install
+pip install .
+```
+
+### Install for Development
+
+```bash
+# Install in editable mode
+pip install -e .
+```
+
+After installation, `kport` will be available globally in your terminal.
+
+### Run Without Installing
+
+```bash
+# Run directly with Python
+python kport.py -h
+```
+
+> 📖 For detailed installation instructions, see [INSTALL.md](INSTALL.md)
+> 
+> 🚀 For publishing instructions, see [PUBLISH.md](PUBLISH.md)
+
+## 🚀 Usage
+
+### Inspect a port
+
+Find out which process is using a specific port:
+
+```bash
+kport -i 8080
+```
+
+Example output:
+```
+🔍 Inspecting port 8080...
+
+✓ Port 8080 is being used by PID 12345
+
+Process Information:
+──────────────────────────────────────────────────
+PID: 12345
+Image Name: node.exe
+Session Name: Console
+Mem Usage: 45,678 K
+```
+
+### Inspect by process name
+
+Find all processes matching a name and see what ports they're using:
+
+```bash
+kport -ip node
+```
+
+Example output:
+```
+🔍 Inspecting processes matching 'node'...
+
+Found 3 connection(s) for processes matching 'node':
+
+PID        Process                   Port       State          
+──────────────────────────────────────────────────────────────────────
+12345      node.exe                  3000       LISTENING      
+                                     3001       LISTENING      
+12346      node.exe                  8080       LISTENING      
+
+✓ Total processes found: 2
+✓ Total connections: 3
+```
+
+### Kill a process on a port
+
+Terminate the process using a specific port:
+
+```bash
+kport -k 8080
+```
+
+Example output:
+```
+🔪 Attempting to kill process on port 8080...
+
+Found PID 12345 using port 8080
+
+Process to be terminated:
+PID: 12345
+Image Name: node.exe
+
+Are you sure you want to kill this process? (y/N): y
+
+✓ Successfully killed process 12345
+Port 8080 is now free.
+```
+
+### List all listening ports
+
+View all active listening ports and their associated processes:
+
+```bash
+kport -l
+```
+
+Example output:
+```
+📋 Listing all active ports...
+
+Protocol   Local Address            State           PID       
+──────────────────────────────────────────────────────────────────────
+TCP        0.0.0.0:80               LISTENING       1234      
+TCP        0.0.0.0:443              LISTENING       1234      
+TCP        0.0.0.0:3000             LISTENING       5678      
+TCP        0.0.0.0:8080             LISTENING       9012
+```
+
+### Kill by process name
+
+Kill all processes matching a specific name:
+
+```bash
+kport -kp node
+```
+
+Example output:
+```
+🔪 Killing all processes matching 'node'...
+
+Found 3 process(es) matching 'node':
+──────────────────────────────────────────────────
+  PID 12345: node.exe
+  PID 12346: node.exe
+  PID 12347: node.exe
+
+Are you sure you want to kill 3 process(es)? (y/N): y
+
+✓ Killed PID 12345
+✓ Killed PID 12346
+✓ Killed PID 12347
+
+✓ Successfully killed 3/3 process(es)
+```
+
+### Kill multiple ports at once
+
+Kill processes on multiple ports simultaneously:
+
+```bash
+kport -ka 3000 3001 3002
+```
+
+Example output:
+```
+🔪 Killing processes on 3 port(s)...
+
+Found processes on 3 port(s):
+──────────────────────────────────────────────────
+  Port 3000: PID 12345 (node.exe)
+  Port 3001: PID 12346 (node.exe)
+  Port 3002: PID 12347 (python.exe)
+
+Are you sure you want to kill 3 process(es)? (y/N): y
+
+✓ Killed process on port 3000 (PID 12345)
+✓ Killed process on port 3001 (PID 12346)
+✓ Killed process on port 3002 (PID 12347)
+
+✓ Successfully killed 3/3 process(es)
+Ports freed: 3000, 3001, 3002
+```
+
+### Show help
+
+```bash
+kport -h
+```
+
+### Show version
+
+```bash
+kport -v
+```
+
+## 📚 Command-Line Options
+
+| Option | Long Form | Description |
+|--------|-----------|-------------|
+| `-i PORT` | `--inspect PORT` | Inspect which process is using the specified port |
+| `-ip NAME` | `--inspect-process NAME` | Inspect all processes matching the given name and their ports |
+| `-k PORT` | `--kill PORT` | Kill the process using the specified port |
+| `-kp NAME` | `--kill-process NAME` | Kill all processes matching the given name |
+| `-ka PORT [PORT ...]` | `--kill-all PORT [PORT ...]` | Kill processes on multiple ports at once |
+| `-l` | `--list` | List all listening ports and their processes |
+| `-v` | `--version` | Show version information |
+| `-h` | `--help` | Show help message |
+
+## 🛠️ Requirements
+
+- Python 3.6 or higher
+- No external dependencies (uses only Python standard library)
+
+### Platform-specific tools
+
+The tool uses platform-native commands:
+
+- **Windows**: `netstat`, `tasklist`, `taskkill`
+- **Linux/macOS**: `lsof`, `ps`, `kill`
+
+These tools are typically pre-installed on all platforms.
+
+## 🔧 Development
+
+### Clone and setup
+
+```bash
+git clone https://github.com/farman20ali/port-killer.git
+cd port-killer
+
+# Install in development mode
+pip install -e .
+```
+
+### Run tests
+
+```bash
+# Test inspecting a port
+kport -i 80
+
+# Test listing ports
+kport -l
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## 📝 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## ⚠️ Important Notes
+
+- **Administrator/sudo privileges**: Killing processes may require elevated privileges on some systems
+- **Port validation**: Port numbers must be between 1 and 65535
+- **Safety**: The tool asks for confirmation before killing any process
+- **Multiple processes**: If multiple processes use the same port, the first one found will be shown/killed
+
+## 🐛 Troubleshooting
+
+### "Permission denied" errors
+
+On Linux/macOS, you may need to run with sudo:
+```bash
+sudo kport -k 80
+```
+
+On Windows, run your terminal as Administrator.
+
+### Port not found
+
+Make sure the port number is correct and that a process is actually using it. Use `kport -l` to see all active ports.
+
+### Color output not working on Windows
+
+Colors should work on Windows 10 and later. If you're on an older version, colors may not display correctly.
+
+## 📧 Contact
+
+Your Name - your.email@example.com
+
+Project Link: [https://github.com/yourusername/port-killer](https://github.com/yourusername/port-killer)
+
+---
+
+Made with ❤️ for developers who are tired of hunting down processes

kport-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+kport.py,sha256=6nx8AasiXMfykoymzkqmAGTQ3OIMkEOoFcKYvApSGgQ,18043
+kport-1.0.0.dist-info/licenses/LICENSE,sha256=QQ8MyuCI55RKsPJcc50I2sT59jvpRtD9kvA031BtYs8,1083
+kport-1.0.0.dist-info/METADATA,sha256=zampNq2_T6Em0La-nnV2DwAtNLwoZsec6d7meG-GPt0,10183
+kport-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kport-1.0.0.dist-info/entry_points.txt,sha256=ppZIgJ1vrmYs2EO9NcVSFCaZj7oj7t6RnJo8ArPQiRo,37
+kport-1.0.0.dist-info/top_level.txt,sha256=yzlMBPZ7a-pcCN4DR5MRPO-VjY3fWnILtFUQpEuA2xY,6
+kport-1.0.0.dist-info/RECORD,,

kport-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kport-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kport = kport:main

kport-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kport
+
+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:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

kport-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+kport

kport.py

@@ -0,0 +1,440 @@
+#!/usr/bin/env python3
+"""
+kport - Cross-platform port inspector and killer
+A simple command-line tool to inspect and kill processes using specific ports
+"""
+import argparse
+import os
+import platform
+import subprocess
+import sys
+import re
+
+
+# ANSI color codes
+class Colors:
+    RED = '\033[91m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    BLUE = '\033[94m'
+    MAGENTA = '\033[95m'
+    CYAN = '\033[96m'
+    WHITE = '\033[97m'
+    BOLD = '\033[1m'
+    RESET = '\033[0m'
+
+
+def colorize(text, color):
+    """Add color to text if terminal supports it"""
+    if platform.system() == "Windows":
+        # Enable ANSI colors on Windows 10+
+        os.system("")
+    return f"{color}{text}{Colors.RESET}"
+
+
+def run(cmd):
+    """Execute shell command and return output"""
+    try:
+        return subprocess.check_output(cmd, shell=True, text=True, stderr=subprocess.DEVNULL)
+    except subprocess.CalledProcessError:
+        return ""
+    except Exception as e:
+        print(colorize(f"Error executing command: {e}", Colors.RED))
+        return ""
+
+
+def validate_port(port):
+    """Validate if port number is in valid range"""
+    if not (1 <= port <= 65535):
+        print(colorize(f"Error: Port {port} is not valid. Port must be between 1 and 65535.", Colors.RED))
+        sys.exit(1)
+
+
+def find_pid(port):
+    """Find process ID using given port"""
+    system = platform.system()
+
+    if system == "Windows":
+        out = run(f"netstat -ano | findstr :{port}")
+        if not out:
+            return None, None
+        
+        # Parse the first line (could be multiple connections)
+        lines = out.strip().split('\n')
+        for line in lines:
+            parts = line.split()
+            if len(parts) >= 5:
+                pid = parts[-1]
+                proc_info = run(f'tasklist /FI "PID eq {pid}" /FO LIST')
+                return pid, proc_info
+        
+        return None, None
+
+    else:  # Linux, Ubuntu, macOS
+        out = run(f"lsof -t -i:{port}")
+        if not out:
+            return None, None
+        
+        pid = out.strip().split('\n')[0]  # Get first PID if multiple
+        proc_info = run(f"ps -p {pid} -o pid,user,command")
+        return pid, proc_info
+
+
+def list_all_ports():
+    """List all listening ports and their processes"""
+    system = platform.system()
+    
+    print(colorize("\n📋 Listing all active ports...\n", Colors.CYAN + Colors.BOLD))
+
+    if system == "Windows":
+        out = run("netstat -ano | findstr LISTENING")
+        if not out:
+            print(colorize("No listening ports found.", Colors.YELLOW))
+            return
+        
+        print(colorize(f"{'Protocol':<10} {'Local Address':<25} {'State':<15} {'PID':<10}", Colors.BOLD))
+        print("─" * 70)
+        
+        for line in out.strip().split('\n'):
+            parts = line.split()
+            if len(parts) >= 5:
+                protocol = parts[0]
+                local_addr = parts[1]
+                state = parts[3]
+                pid = parts[4]
+                print(f"{protocol:<10} {local_addr:<25} {state:<15} {pid:<10}")
+
+    else:  # Linux, Ubuntu, macOS
+        out = run("lsof -i -P -n | grep LISTEN")
+        if not out:
+            print(colorize("No listening ports found.", Colors.YELLOW))
+            return
+        
+        print(colorize(f"{'Command':<20} {'PID':<10} {'User':<15} {'Address':<30}", Colors.BOLD))
+        print("─" * 80)
+        
+        for line in out.strip().split('\n'):
+            parts = line.split()
+            if len(parts) >= 9:
+                command = parts[0]
+                pid = parts[1]
+                user = parts[2]
+                address = parts[8]
+                print(f"{command:<20} {pid:<10} {user:<15} {address:<30}")
+
+
+def find_pids_by_process_name(process_name):
+    """Find all PIDs matching a process name"""
+    system = platform.system()
+    pids = []
+
+    if system == "Windows":
+        out = run(f'tasklist /FI "IMAGENAME eq {process_name}*" /FO CSV /NH')
+        if out:
+            for line in out.strip().split('\n'):
+                parts = line.replace('"', '').split(',')
+                if len(parts) >= 2:
+                    try:
+                        pid = parts[1]
+                        pids.append(pid)
+                    except (ValueError, IndexError):
+                        continue
+    else:  # Linux, Ubuntu, macOS
+        out = run(f"pgrep -f {process_name}")
+        if out:
+            pids = [pid.strip() for pid in out.strip().split('\n') if pid.strip()]
+    
+    return pids
+
+
+def get_process_name(pid):
+    """Get process name from PID"""
+    system = platform.system()
+    
+    if system == "Windows":
+        out = run(f'tasklist /FI "PID eq {pid}" /FO CSV /NH')
+        if out:
+            parts = out.strip().split(',')[0].replace('"', '')
+            return parts
+    else:
+        out = run(f"ps -p {pid} -o comm=")
+        if out:
+            return out.strip()
+    
+    return "Unknown"
+
+
+def find_ports_by_process_name(process_name):
+    """Find all ports used by processes matching a name"""
+    system = platform.system()
+    process_port_map = []  # List of tuples: (pid, process_name, port)
+    
+    if system == "Windows":
+        # Get all PIDs matching the process name
+        pids = find_pids_by_process_name(process_name)
+        
+        if pids:
+            # For each PID, find what ports it's using
+            for pid in pids:
+                out = run(f"netstat -ano | findstr {pid}")
+                if out:
+                    proc_name = get_process_name(pid)
+                    ports_seen = set()
+                    
+                    for line in out.strip().split('\n'):
+                        parts = line.split()
+                        if len(parts) >= 5 and parts[-1] == pid:
+                            # Extract port from local address (format: IP:PORT)
+                            local_addr = parts[1]
+                            if ':' in local_addr:
+                                port = local_addr.split(':')[-1]
+                                if port not in ports_seen:
+                                    ports_seen.add(port)
+                                    state = parts[3] if len(parts) > 3 else "UNKNOWN"
+                                    process_port_map.append((pid, proc_name, port, state))
+    
+    else:  # Linux, Ubuntu, macOS
+        # Use lsof to find ports by process name
+        out = run(f"lsof -i -P -n | grep -i {process_name}")
+        if out:
+            for line in out.strip().split('\n'):
+                parts = line.split()
+                if len(parts) >= 9:
+                    command = parts[0]
+                    pid = parts[1]
+                    # Extract port from address (format: *:PORT or IP:PORT)
+                    address = parts[8]
+                    if ':' in address:
+                        port = address.split(':')[-1]
+                        # Filter out non-LISTEN states if needed
+                        state = "LISTEN" if "LISTEN" in line else "ESTABLISHED"
+                        process_port_map.append((pid, command, port, state))
+    
+    return process_port_map
+
+
+def kill_pid(pid, silent=False):
+    """Kill process by PID"""
+    system = platform.system()
+
+    if system == "Windows":
+        result = run(f"taskkill /PID {pid} /F")
+        return result
+    else:
+        result = run(f"kill -9 {pid}")
+        return result if result else "Process killed successfully"
+
+
+def main():
+    """Main entry point"""
+    parser = argparse.ArgumentParser(
+        description="🔪 kport - Cross-platform port inspector and killer",
+        epilog="Examples:\n"
+               "  kport -i 8080              Inspect port 8080\n"
+               "  kport -ip node             Inspect all processes matching 'node'\n"
+               "  kport -k 8080              Kill process using port 8080\n"
+               "  kport -l                   List all listening ports\n"
+               "  kport -kp node             Kill all processes matching 'node'\n"
+               "  kport -ka 3000 3001 3002   Kill processes on multiple ports\n",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("-i", "--inspect", type=int, metavar="PORT", 
+                       help="Inspect which process is using the specified port")
+    parser.add_argument("-ip", "--inspect-process", type=str, metavar="NAME",
+                       help="Inspect all processes matching the given name")
+    parser.add_argument("-k", "--kill", type=int, metavar="PORT",
+                       help="Kill the process using the specified port")
+    parser.add_argument("-kp", "--kill-process", type=str, metavar="NAME",
+                       help="Kill all processes matching the given name")
+    parser.add_argument("-ka", "--kill-all", type=int, nargs="+", metavar="PORT",
+                       help="Kill processes on multiple ports")
+    parser.add_argument("-l", "--list", action="store_true",
+                       help="List all listening ports and their processes")
+    parser.add_argument("-v", "--version", action="version", version="kport 1.0.0")
+
+    args = parser.parse_args()
+
+    # If no arguments provided, show help
+    if not (args.inspect or args.inspect_process or args.kill or args.list or args.kill_process or args.kill_all):
+        parser.print_help()
+        sys.exit(0)
+
+    if args.list:
+        list_all_ports()
+
+    if args.inspect_process:
+        print(colorize(f"\n🔍 Inspecting processes matching '{args.inspect_process}'...\n", Colors.CYAN + Colors.BOLD))
+        
+        process_info = find_ports_by_process_name(args.inspect_process)
+        
+        if not process_info:
+            print(colorize(f"❌ No processes found matching '{args.inspect_process}'", Colors.RED))
+        else:
+            print(colorize(f"Found {len(process_info)} connection(s) for processes matching '{args.inspect_process}':\n", Colors.YELLOW))
+            
+            # Group by PID for better display
+            pid_groups = {}
+            for pid, proc_name, port, state in process_info:
+                if pid not in pid_groups:
+                    pid_groups[pid] = {'name': proc_name, 'ports': []}
+                pid_groups[pid]['ports'].append((port, state))
+            
+            print(colorize(f"{'PID':<10} {'Process':<25} {'Port':<10} {'State':<15}", Colors.BOLD))
+            print("─" * 70)
+            
+            for pid, data in pid_groups.items():
+                proc_name = data['name']
+                ports = data['ports']
+                
+                # Print first port
+                if ports:
+                    port, state = ports[0]
+                    print(f"{colorize(pid, Colors.CYAN):<19} {proc_name:<25} {port:<10} {state:<15}")
+                    
+                    # Print additional ports for same PID
+                    for port, state in ports[1:]:
+                        print(f"{'':<10} {'':<25} {port:<10} {state:<15}")
+            
+            print(colorize(f"\n✓ Total processes found: {len(pid_groups)}", Colors.GREEN))
+            print(colorize(f"✓ Total connections: {len(process_info)}", Colors.GREEN))
+
+    if args.kill_process:
+        print(colorize(f"\n🔪 Killing all processes matching '{args.kill_process}'...\n", Colors.CYAN + Colors.BOLD))
+        
+        pids = find_pids_by_process_name(args.kill_process)
+        if not pids:
+            print(colorize(f"❌ No processes found matching '{args.kill_process}'", Colors.RED))
+        else:
+            print(colorize(f"Found {len(pids)} process(es) matching '{args.kill_process}':", Colors.YELLOW))
+            print("─" * 50)
+            
+            for pid in pids:
+                proc_name = get_process_name(pid)
+                print(colorize(f"  PID {pid}: {proc_name}", Colors.WHITE))
+            
+            # Ask for confirmation
+            try:
+                confirm = input(colorize(f"\nAre you sure you want to kill {len(pids)} process(es)? (y/N): ", Colors.MAGENTA))
+                if confirm.lower() not in ['y', 'yes']:
+                    print(colorize("Operation cancelled.", Colors.YELLOW))
+                    sys.exit(0)
+            except KeyboardInterrupt:
+                print(colorize("\n\nOperation cancelled.", Colors.YELLOW))
+                sys.exit(0)
+            
+            # Kill all processes
+            killed_count = 0
+            for pid in pids:
+                result = kill_pid(pid, silent=True)
+                if result or "SUCCESS" in str(result) or "killed" in str(result).lower():
+                    killed_count += 1
+                    print(colorize(f"✓ Killed PID {pid}", Colors.GREEN))
+                else:
+                    print(colorize(f"✗ Failed to kill PID {pid}", Colors.RED))
+            
+            print(colorize(f"\n✓ Successfully killed {killed_count}/{len(pids)} process(es)", Colors.GREEN + Colors.BOLD))
+
+    if args.kill_all:
+        print(colorize(f"\n🔪 Killing processes on {len(args.kill_all)} port(s)...\n", Colors.CYAN + Colors.BOLD))
+        
+        # Validate all ports first
+        for port in args.kill_all:
+            validate_port(port)
+        
+        # Find all PIDs
+        port_pid_map = {}
+        for port in args.kill_all:
+            pid, info = find_pid(port)
+            if pid:
+                port_pid_map[port] = (pid, info)
+        
+        if not port_pid_map:
+            print(colorize(f"❌ No processes found on any of the specified ports", Colors.RED))
+        else:
+            print(colorize(f"Found processes on {len(port_pid_map)} port(s):", Colors.YELLOW))
+            print("─" * 50)
+            
+            for port, (pid, info) in port_pid_map.items():
+                proc_name = get_process_name(pid)
+                print(colorize(f"  Port {port}: PID {pid} ({proc_name})", Colors.WHITE))
+            
+            # Ask for confirmation
+            try:
+                confirm = input(colorize(f"\nAre you sure you want to kill {len(port_pid_map)} process(es)? (y/N): ", Colors.MAGENTA))
+                if confirm.lower() not in ['y', 'yes']:
+                    print(colorize("Operation cancelled.", Colors.YELLOW))
+                    sys.exit(0)
+            except KeyboardInterrupt:
+                print(colorize("\n\nOperation cancelled.", Colors.YELLOW))
+                sys.exit(0)
+            
+            # Kill all processes
+            killed_count = 0
+            for port, (pid, info) in port_pid_map.items():
+                result = kill_pid(pid, silent=True)
+                if result or "SUCCESS" in str(result) or "killed" in str(result).lower():
+                    killed_count += 1
+                    print(colorize(f"✓ Killed process on port {port} (PID {pid})", Colors.GREEN))
+                else:
+                    print(colorize(f"✗ Failed to kill process on port {port} (PID {pid})", Colors.RED))
+            
+            print(colorize(f"\n✓ Successfully killed {killed_count}/{len(port_pid_map)} process(es)", Colors.GREEN + Colors.BOLD))
+            print(colorize(f"Ports freed: {', '.join(map(str, port_pid_map.keys()))}", Colors.GREEN))
+
+    if args.inspect:
+        validate_port(args.inspect)
+        print(colorize(f"\n🔍 Inspecting port {args.inspect}...\n", Colors.CYAN + Colors.BOLD))
+        
+        pid, info = find_pid(args.inspect)
+        if not pid:
+            print(colorize(f"❌ No process found using port {args.inspect}", Colors.RED))
+        else:
+            print(colorize(f"✓ Port {args.inspect} is being used by PID {pid}", Colors.GREEN + Colors.BOLD))
+            print(colorize("\nProcess Information:", Colors.YELLOW))
+            print("─" * 50)
+            print(info)
+
+    if args.kill:
+        validate_port(args.kill)
+        print(colorize(f"\n🔪 Attempting to kill process on port {args.kill}...\n", Colors.CYAN + Colors.BOLD))
+        
+        pid, info = find_pid(args.kill)
+        if not pid:
+            print(colorize(f"❌ No process found using port {args.kill}", Colors.RED))
+        else:
+            print(colorize(f"Found PID {pid} using port {args.kill}", Colors.YELLOW))
+            
+            # Show process info before killing
+            if info:
+                print(colorize("\nProcess to be terminated:", Colors.YELLOW))
+                print(info)
+            
+            # Ask for confirmation
+            try:
+                confirm = input(colorize("\nAre you sure you want to kill this process? (y/N): ", Colors.MAGENTA))
+                if confirm.lower() not in ['y', 'yes']:
+                    print(colorize("Operation cancelled.", Colors.YELLOW))
+                    sys.exit(0)
+            except KeyboardInterrupt:
+                print(colorize("\n\nOperation cancelled.", Colors.YELLOW))
+                sys.exit(0)
+            
+            result = kill_pid(pid)
+            if result:
+                print(colorize(f"\n✓ Successfully killed process {pid}", Colors.GREEN + Colors.BOLD))
+                if "SUCCESS" in result or "killed" in result.lower():
+                    print(colorize(f"Port {args.kill} is now free.", Colors.GREEN))
+            else:
+                print(colorize(f"\n❌ Failed to kill process {pid}", Colors.RED))
+                print(colorize("You may need administrator/sudo privileges.", Colors.YELLOW))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print(colorize("\n\nOperation cancelled by user.", Colors.YELLOW))
+        sys.exit(0)
+    except Exception as e:
+        print(colorize(f"\nUnexpected error: {e}", Colors.RED))
+        sys.exit(1)