kport 3.1.0__py3-none-any.whl → 3.1.1__py3-none-any.whl

{kport-3.1.0.dist-info → kport-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kport
-Version: 3.1.0
+Version: 3.1.1
 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
@@ -13,7 +13,7 @@ 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: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
@@ -46,7 +46,7 @@ Dynamic: summary
 
 [![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)](https://github.com/farman20ali/port-killer)
 [![Python](https://img.shields.io/badge/python-3.6+-blue.svg)](https://www.python.org/downloads/)
-[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![License](https://img.shields.io/badge/license-AGPL--3.0-blue.svg)](LICENSE)
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg)](https://github.com/farman20ali/port-killer)
 
 A simple, powerful command-line tool to inspect and kill processes using specific ports on Windows, Linux, and macOS.
@@ -472,6 +472,33 @@ kport -i 80
 kport -l
 ```
 
+## 📚 Documentation
+
+- **[Installation Guide](INSTALL.md)** - Detailed installation instructions
+- **[Quick Start](QUICKSTART.md)** - Get started quickly
+- **[Publishing Guide](PUBLISH.md)** - How to publish kport
+- **[Release Guide](RELEASE_GUIDE.md)** - Creating releases (manual & automated)
+- **[Debian Release](DEB_RELEASE.md)** - Debian packaging and APT distribution
+- **[Contributing](CONTRIBUTING.md)** - How to contribute
+
+## 🚀 For Maintainers
+
+### Creating a Release
+
+Automated release (recommended):
+
+```bash
+python3 release.py
+```
+
+This script handles:
+- Git tagging
+- PyPI package building
+- Debian package building  
+- GitHub release creation
+
+See [RELEASE_GUIDE.md](RELEASE_GUIDE.md) for manual release steps and troubleshooting.
+
 ## 🤝 Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.
@@ -484,7 +511,15 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## 📝 License
 
-This project is licensed under the MIT License - see the LICENSE file for details.
+This project is licensed under the GNU Affero General Public License v3.0 - see the [LICENSE](LICENSE) file for details.
+
+**What this means:**
+- ✅ Free to use, modify, and distribute
+- ✅ Must share source code of any modifications
+- ✅ **Network use = distribution**: If you run a modified version as a service, you must share the source code
+- ❌ Cannot use in proprietary SaaS without sharing modifications
+
+For commercial licensing or if AGPL doesn't fit your use case, contact: farman20ali@gmail.com
 
 ## ⚠️ Important Notes
 
@@ -504,6 +539,38 @@ sudo kport -k 80
 
 On Windows, run your terminal as Administrator.
 
+### Stubborn processes that won't die
+
+Some processes (especially Java applications) may not respond to graceful termination. Use the `--force` flag which automatically uses a multi-tier kill strategy (SIGTERM → SIGKILL → fuser):
+
+```bash
+kport -k 8081 --force
+```
+
+On Linux, `kport` will automatically use `fuser -k` as a fallback when standard kill methods fail. This is extremely effective for stubborn Java/Node/Python processes:
+
+```bash
+# Install fuser for best results (Ubuntu/Debian)
+sudo apt-get install psmisc
+
+# Install fuser (RHEL/CentOS/Fedora)
+sudo yum install psmisc
+
+# Then kport will automatically use it when needed
+kport -k 8081 --force
+```
+
+**What happens:**
+1. First tries SIGTERM (graceful shutdown)
+2. Then tries SIGKILL after timeout
+3. Finally uses `fuser -k 8081/tcp` if process still lives (Linux only)
+
+**Manual alternative:** You can also kill a port directly with fuser:
+```bash
+# Kill all processes using port 8081 (requires sudo)
+sudo fuser -k 8081/tcp
+```
+
 ### 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.

kport-3.1.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+kport.py,sha256=eSHSppNOn2Yfd0ytBbwE2yHu51b7nS82ROGIWZL0ozA,88268
+kport-3.1.1.dist-info/licenses/LICENSE,sha256=PCHih_8Dwem_jeC81AMDn1Vjj8BqSbIgDYouqXsNsN8,1314
+kport-3.1.1.dist-info/METADATA,sha256=deC0pH0jnPGSEpW1dfP3SeG74MNQYmpjPpvx8zWAPAY,16847
+kport-3.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+kport-3.1.1.dist-info/entry_points.txt,sha256=ppZIgJ1vrmYs2EO9NcVSFCaZj7oj7t6RnJo8ArPQiRo,37
+kport-3.1.1.dist-info/top_level.txt,sha256=yzlMBPZ7a-pcCN4DR5MRPO-VjY3fWnILtFUQpEuA2xY,6
+kport-3.1.1.dist-info/RECORD,,

{kport-3.1.0.dist-info → kport-3.1.1.dist-info}/WHEEL

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

kport-3.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,30 @@
+GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, 19 November 2007
+
+Copyright (C) 2025 kport contributors
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+--------------------------------------------------------------------------
+
+NOTE: This is the AGPL-3.0 license, which is similar to GPL-3.0 but with
+an additional requirement: If you run a modified version of this program
+on a server and let users interact with it remotely through a network,
+you must make the complete source code of your modified version available
+to those users.
+
+This protects against the "SaaS loophole" where companies could use the
+software as a service without sharing their modifications.
+
+Full license text: https://www.gnu.org/licenses/agpl-3.0.txt

kport.py

@@ -381,6 +381,32 @@ class BaseInspector:
         """
         raise NotImplementedError()
 
+    def kill_port(self, port: int, graceful_timeout: float = 3.0, force: bool = False, dry_run: bool = False) -> Tuple[bool, str]:
+        """
+        Kill all processes using a specific port.
+        Default implementation finds PIDs and kills them one by one.
+        Can be overridden for more efficient port-based killing (e.g., fuser on Linux).
+        """
+        pids = self.find_pids_on_port(port)
+        if not pids:
+            return False, "No process found on port"
+        
+        killed_count = 0
+        errors = []
+        for pid in pids:
+            ok, msg = self.kill_pid(pid, graceful_timeout, force, dry_run)
+            if ok:
+                killed_count += 1
+            else:
+                errors.append(f"PID {pid}: {msg}")
+        
+        if killed_count == len(pids):
+            return True, f"Killed {killed_count} process(es)"
+        elif killed_count > 0:
+            return False, f"Killed {killed_count}/{len(pids)} process(es). Errors: {'; '.join(errors)}"
+        else:
+            return False, f"Failed to kill any process. Errors: {'; '.join(errors)}"
+
 # psutil-based inspector (best behavior cross-platform)
 class PsutilInspector(BaseInspector):
     def list_listening(self) -> List[PortBinding]:
@@ -551,6 +577,38 @@ class FallbackInspector(BaseInspector):
         except Exception:
             return None
 
+    def _kill_port_with_fuser(self, port: int, proto: str = "tcp", dry_run: bool = False) -> Tuple[bool, str]:
+        """Kill all processes using a port with fuser (Linux utility).
+        
+        This is often more reliable than kill -9 for stubborn processes.
+        """
+        if dry_run:
+            return True, f"Dry-run: would fuser -k {port}/{proto}"
+        
+        if not check_dependency("fuser"):
+            return False, "fuser not available"
+        
+        try:
+            # fuser -k sends SIGKILL by default to all processes using the port
+            proc = subprocess.run(
+                ["fuser", "-k", f"{port}/{proto}"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            # fuser returns 0 on success, 1 if no process found
+            if proc.returncode == 0:
+                return True, f"Killed process(es) using port {port} with fuser"
+            elif proc.returncode == 1:
+                return False, "No process found on port"
+            else:
+                stderr = (proc.stderr or "").strip()
+                return False, f"fuser failed: {stderr}"
+        except subprocess.TimeoutExpired:
+            return False, "fuser command timed out"
+        except Exception as e:
+            return False, f"Error running fuser: {e}"
+
     def list_listening(self) -> List[PortBinding]:
         if self.system == "Windows":
             return self._windows_listening()
@@ -907,7 +965,7 @@ class FallbackInspector(BaseInspector):
                         return False, f"Error taskkill: {e}"
                 return False, "Still running; taskkill gentle failed"
             else:
-                # Unix: try SIGTERM then SIGKILL
+                # Unix: try SIGTERM then SIGKILL, with multiple attempts
                 try:
                     os.kill(pid, signal.SIGTERM)
                 except PermissionError:
@@ -932,19 +990,46 @@ class FallbackInspector(BaseInspector):
                         return False, "Permission denied"
                 if not force:
                     return False, "Still alive after graceful timeout"
-                # force kill
+                # force kill with SIGKILL
                 try:
                     os.kill(pid, signal.SIGKILL)
-                    return True, "Killed (SIGKILL)"
+                    # Wait briefly to confirm kill
+                    time.sleep(0.5)
+                    try:
+                        os.kill(pid, 0)
+                        # Process still exists, might need more aggressive approach
+                    except ProcessLookupError:
+                        return True, "Killed (SIGKILL)"
+                    except PermissionError:
+                        return False, "Permission denied"
                 except PermissionError:
                     return False, "Permission denied on SIGKILL"
                 except ProcessLookupError:
-                    return True, "Process disappeared after SIGKILL"
+                    return True, "Process disappeared"
                 except Exception as e:
                     return False, f"Error SIGKILL: {e}"
+                
+                # If still running, return status indicating process is stubborn
+                return False, "Process did not terminate after SIGKILL"
         except Exception as e:
             return False, f"Unexpected error: {e}"
 
+    def kill_port(self, port: int, graceful_timeout: float = 3.0, force: bool = False, dry_run: bool = False) -> Tuple[bool, str]:
+        """
+        Kill all processes using a specific port.
+        On Linux, tries fuser first as it's more reliable, then falls back to default implementation.
+        """
+        if self.system != "Windows":
+            # Try fuser first on Unix-like systems when force=True or as fallback
+            if force and check_dependency("fuser"):
+                ok, msg = self._kill_port_with_fuser(port, "tcp", dry_run)
+                if ok:
+                    return ok, msg
+                # If fuser fails, fall through to default implementation
+        
+        # Use default implementation: find PIDs and kill them
+        return super().kill_port(port, graceful_timeout, force, dry_run)
+
 # Factory
 def get_inspector() -> BaseInspector:
     if USING_PSUTIL:
@@ -1291,6 +1376,23 @@ def handle_product_command(args: argparse.Namespace, inspector: BaseInspector) -
                 out_killed.append({"pid": pid, "msg": msg})
             else:
                 out_failed.append({"pid": pid, "msg": msg})
+        
+        # If any processes failed to kill and fuser is available on Linux, try as last resort
+        if out_failed and isinstance(inspector, FallbackInspector) and inspector.system != "Windows" and check_dependency("fuser"):
+            if not args.json:
+                print(colorize(f"\n⚠ Some processes couldn't be killed. Trying fuser as fallback...", Colors.YELLOW))
+            fuser_ok, fuser_msg = inspector._kill_port_with_fuser(args.port, "tcp", dry_run=args.dry_run)
+            if fuser_ok:
+                # Re-check if processes are gone
+                remaining_pids = inspector.find_pids_on_port(args.port)
+                if not remaining_pids:
+                    # Success! Mark all failed as killed
+                    for f in out_failed:
+                        out_killed.append({"pid": f["pid"], "msg": f"{f['msg']} → killed with fuser"})
+                    out_failed = []
+                    if not args.json:
+                        print(colorize(f"✓ {fuser_msg}", Colors.GREEN))
+        
         if args.json:
             print(json.dumps({"port": args.port, "killed": out_killed, "failed": out_failed}, indent=2))
         else:
@@ -1400,9 +1502,9 @@ Examples:
     parser.add_argument("-kr", "--kill-range", type=str, metavar="RANGE", help="Kill processes on port range (e.g., 3000-3010)")
     parser.add_argument("-l", "--list", action="store_true", help="List all listening ports and their processes")
     parser.add_argument("--exact", action="store_true", help="Use exact match for process name lookups")
-    parser.add_argument("--force", action="store_true", help="Force kill immediately if needed (after graceful timeout)")
+    parser.add_argument("--force", action="store_true", help="Force kill immediately if needed (uses SIGKILL/fuser on Linux for stubborn processes)")
     parser.add_argument("--graceful-timeout", type=float, default=3.0, help="Seconds to wait for graceful termination before forcing (default 3.0)")
-    parser.add_argument("-v", "--version", action="version", version="kport 3.1.0")
+    parser.add_argument("-v", "--version", action="version", version="kport 3.1.1")
 
     # PRODUCT.md subcommands
     sub = parser.add_subparsers(dest="command")

kport-3.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-kport.py,sha256=0swOnRrBMCpTm9Ivr8dDEjN9iJw9VLYX8ce_1LrDIFE,83354
-kport-3.1.0.dist-info/licenses/LICENSE,sha256=jIMuFOo3loyUX7Yc92eFXDJC9Wo1ASX5j3qdIDs4ceo,1062
-kport-3.1.0.dist-info/METADATA,sha256=1qLqNT6HH4-v-25XXQpLNQQECvAFbWjiVJxycDFgzp4,14644
-kport-3.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kport-3.1.0.dist-info/entry_points.txt,sha256=ppZIgJ1vrmYs2EO9NcVSFCaZj7oj7t6RnJo8ArPQiRo,37
-kport-3.1.0.dist-info/top_level.txt,sha256=yzlMBPZ7a-pcCN4DR5MRPO-VjY3fWnILtFUQpEuA2xY,6
-kport-3.1.0.dist-info/RECORD,,

kport-3.1.0.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-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.