portcheck-cli 0.1.0__tar.gz

portcheck_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marcus
+
+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.

portcheck_cli-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: portcheck-cli
+Version: 0.1.0
+Summary: Check what's using a port and optionally kill it
+Author-email: Marcus <marcus.builds.things@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/marcusbuildsthings-droid/portcheck
+Project-URL: Repository, https://github.com/marcusbuildsthings-droid/portcheck
+Keywords: port,network,cli,process,kill,lsof
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: psutil>=5.9
+Dynamic: license-file
+
+# portcheck
+
+Check what's using a port and optionally kill it.
+
+Simple, fast, with JSON output for automation.
+
+## Installation
+
+```bash
+pip install portcheck-cli
+```
+
+## Usage
+
+### Check a specific port
+
+```bash
+# See what's on port 8080
+portcheck check 8080
+
+# Kill whatever's using port 8080
+portcheck check 8080 --kill
+
+# Force kill without confirmation
+portcheck check 8080 --kill -f -y
+
+# Check UDP port
+portcheck check 53 --udp
+
+# Get JSON output
+portcheck check 8080 --json
+```
+
+### Scan a range of ports
+
+```bash
+# Scan ports 8000-9000
+portcheck scan 8000 9000
+
+# Get JSON output
+portcheck scan 3000 3100 --json
+```
+
+### List all listening ports
+
+```bash
+portcheck list
+
+# JSON output
+portcheck list --json
+```
+
+### Kill a process by PID
+
+```bash
+portcheck kill 12345
+portcheck kill 12345 -f -y  # Force, no confirm
+```
+
+## JSON Output
+
+All commands support `--json` for machine-readable output:
+
+```json
+[
+  {
+    "port": 8080,
+    "protocol": "TCP",
+    "status": "LISTEN",
+    "pid": 12345,
+    "local_address": "127.0.0.1:8080",
+    "name": "python",
+    "cmdline": "python -m http.server 8080",
+    "user": "ape"
+  }
+]
+```
+
+## For AI Agents
+
+See [SKILL.md](SKILL.md) for agent-optimized documentation.
+
+## License
+
+MIT

portcheck_cli-0.1.0/README.md

@@ -0,0 +1,85 @@
+# portcheck
+
+Check what's using a port and optionally kill it.
+
+Simple, fast, with JSON output for automation.
+
+## Installation
+
+```bash
+pip install portcheck-cli
+```
+
+## Usage
+
+### Check a specific port
+
+```bash
+# See what's on port 8080
+portcheck check 8080
+
+# Kill whatever's using port 8080
+portcheck check 8080 --kill
+
+# Force kill without confirmation
+portcheck check 8080 --kill -f -y
+
+# Check UDP port
+portcheck check 53 --udp
+
+# Get JSON output
+portcheck check 8080 --json
+```
+
+### Scan a range of ports
+
+```bash
+# Scan ports 8000-9000
+portcheck scan 8000 9000
+
+# Get JSON output
+portcheck scan 3000 3100 --json
+```
+
+### List all listening ports
+
+```bash
+portcheck list
+
+# JSON output
+portcheck list --json
+```
+
+### Kill a process by PID
+
+```bash
+portcheck kill 12345
+portcheck kill 12345 -f -y  # Force, no confirm
+```
+
+## JSON Output
+
+All commands support `--json` for machine-readable output:
+
+```json
+[
+  {
+    "port": 8080,
+    "protocol": "TCP",
+    "status": "LISTEN",
+    "pid": 12345,
+    "local_address": "127.0.0.1:8080",
+    "name": "python",
+    "cmdline": "python -m http.server 8080",
+    "user": "ape"
+  }
+]
+```
+
+## For AI Agents
+
+See [SKILL.md](SKILL.md) for agent-optimized documentation.
+
+## License
+
+MIT

portcheck_cli-0.1.0/portcheck/__init__.py

@@ -0,0 +1,2 @@
+"""portcheck - Check what's using a port and optionally kill it."""
+__version__ = "0.1.0"

portcheck_cli-0.1.0/portcheck/cli.py

@@ -0,0 +1,444 @@
+#!/usr/bin/env python3
+"""portcheck - Check what's using a port and optionally kill it."""
+
+import json
+import os
+import platform
+import re
+import signal
+import subprocess
+import sys
+from typing import Optional
+
+import click
+import psutil
+
+
+def get_process_on_port_lsof(port: int, protocol: str = "tcp") -> list[dict]:
+    """Use lsof to find processes on a port (macOS/Linux fallback)."""
+    results = []
+    proto_flag = "-iTCP" if protocol == "tcp" else "-iUDP"
+    
+    try:
+        output = subprocess.run(
+            ["lsof", proto_flag + f":{port}", "-nP"],
+            capture_output=True,
+            text=True
+        )
+        
+        for line in output.stdout.strip().split("\n")[1:]:  # Skip header
+            if not line:
+                continue
+            
+            parts = line.split()
+            if len(parts) >= 9:
+                proc_info = {
+                    "port": port,
+                    "protocol": protocol.upper(),
+                    "name": parts[0],
+                    "pid": int(parts[1]) if parts[1].isdigit() else None,
+                    "user": parts[2],
+                    "local_address": parts[8] if len(parts) > 8 else "",
+                    "status": parts[9] if len(parts) > 9 else "LISTEN",
+                }
+                
+                # Get cmdline if we have pid
+                if proc_info["pid"]:
+                    try:
+                        proc = psutil.Process(proc_info["pid"])
+                        proc_info["cmdline"] = " ".join(proc.cmdline())
+                    except (psutil.NoSuchProcess, psutil.AccessDenied):
+                        pass
+                
+                results.append(proc_info)
+    except FileNotFoundError:
+        pass  # lsof not available
+    
+    return results
+
+
+def get_process_on_port_psutil(port: int, protocol: str = "tcp") -> list[dict]:
+    """Use psutil to find processes on a port."""
+    results = []
+    
+    for conn in psutil.net_connections(kind=protocol):
+        if conn.laddr and conn.laddr.port == port:
+            proc_info = {
+                "port": port,
+                "protocol": protocol.upper(),
+                "status": conn.status,
+                "pid": conn.pid,
+                "local_address": f"{conn.laddr.ip}:{conn.laddr.port}",
+            }
+            
+            if conn.raddr:
+                proc_info["remote_address"] = f"{conn.raddr.ip}:{conn.raddr.port}"
+            
+            if conn.pid:
+                try:
+                    proc = psutil.Process(conn.pid)
+                    proc_info["name"] = proc.name()
+                    proc_info["cmdline"] = " ".join(proc.cmdline())
+                    proc_info["user"] = proc.username()
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    pass
+            
+            results.append(proc_info)
+    
+    return results
+
+
+def get_process_on_port(port: int, protocol: str = "tcp") -> list[dict]:
+    """Find processes on a port. Uses lsof on macOS, psutil elsewhere."""
+    # Try lsof first on macOS (works without special permissions)
+    if platform.system() == "Darwin":
+        results = get_process_on_port_lsof(port, protocol)
+        if results:
+            return results
+    
+    # Fall back to psutil
+    try:
+        return get_process_on_port_psutil(port, protocol)
+    except psutil.AccessDenied:
+        # On macOS, try lsof as last resort
+        return get_process_on_port_lsof(port, protocol)
+
+
+def scan_ports_lsof(start: int, end: int, protocol: str = "tcp") -> list[dict]:
+    """Scan port range using lsof."""
+    results = []
+    proto_flag = "-iTCP" if protocol == "tcp" else "-iUDP"
+    
+    try:
+        output = subprocess.run(
+            ["lsof", proto_flag, "-nP", "-sTCP:LISTEN"],
+            capture_output=True,
+            text=True
+        )
+        
+        port_re = re.compile(r":(\d+)\s")
+        
+        for line in output.stdout.strip().split("\n")[1:]:
+            if not line:
+                continue
+            
+            match = port_re.search(line)
+            if match:
+                port = int(match.group(1))
+                if start <= port <= end:
+                    parts = line.split()
+                    if len(parts) >= 3:
+                        results.append({
+                            "port": port,
+                            "protocol": protocol.upper(),
+                            "name": parts[0],
+                            "pid": int(parts[1]) if parts[1].isdigit() else None,
+                            "user": parts[2],
+                            "status": "LISTEN",
+                        })
+    except FileNotFoundError:
+        pass
+    
+    # Dedupe by port
+    seen = set()
+    deduped = []
+    for r in results:
+        if r["port"] not in seen:
+            seen.add(r["port"])
+            deduped.append(r)
+    
+    return sorted(deduped, key=lambda x: x["port"])
+
+
+def scan_ports(start: int, end: int, protocol: str = "tcp") -> list[dict]:
+    """Scan a range of ports for listeners."""
+    # Use lsof on macOS
+    if platform.system() == "Darwin":
+        results = scan_ports_lsof(start, end, protocol)
+        if results:
+            return results
+    
+    # Fall back to psutil
+    results = []
+    seen_ports = set()
+    
+    try:
+        for conn in psutil.net_connections(kind=protocol):
+            if conn.laddr and start <= conn.laddr.port <= end:
+                if conn.laddr.port not in seen_ports:
+                    results.extend(get_process_on_port(conn.laddr.port, protocol))
+                    seen_ports.add(conn.laddr.port)
+    except psutil.AccessDenied:
+        return scan_ports_lsof(start, end, protocol)
+    
+    return sorted(results, key=lambda x: x["port"])
+
+
+def list_listening_lsof() -> list[dict]:
+    """List all listening ports using lsof."""
+    results = []
+    
+    try:
+        output = subprocess.run(
+            ["lsof", "-iTCP", "-nP", "-sTCP:LISTEN"],
+            capture_output=True,
+            text=True
+        )
+        
+        port_re = re.compile(r":(\d+)\s")
+        
+        for line in output.stdout.strip().split("\n")[1:]:
+            if not line:
+                continue
+            
+            match = port_re.search(line)
+            if match:
+                port = int(match.group(1))
+                parts = line.split()
+                if len(parts) >= 9:
+                    addr_parts = parts[8].split(":")
+                    address = addr_parts[0] if len(addr_parts) > 1 else "*"
+                    
+                    results.append({
+                        "port": port,
+                        "address": address,
+                        "pid": int(parts[1]) if parts[1].isdigit() else None,
+                        "name": parts[0],
+                        "user": parts[2],
+                    })
+    except FileNotFoundError:
+        pass
+    
+    # Dedupe
+    seen = set()
+    deduped = []
+    for r in results:
+        if r["port"] not in seen:
+            seen.add(r["port"])
+            deduped.append(r)
+    
+    return sorted(deduped, key=lambda x: x["port"])
+
+
+def kill_process(pid: int, force: bool = False) -> bool:
+    """Kill a process by PID."""
+    try:
+        proc = psutil.Process(pid)
+        if force:
+            proc.kill()  # SIGKILL
+        else:
+            proc.terminate()  # SIGTERM
+        return True
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        # Try os.kill as fallback
+        try:
+            sig = signal.SIGKILL if force else signal.SIGTERM
+            os.kill(pid, sig)
+            return True
+        except (ProcessLookupError, PermissionError):
+            return False
+
+
+@click.group()
+@click.version_option()
+def main():
+    """Check what's using a port and optionally kill it."""
+    pass
+
+
+@main.command()
+@click.argument("port", type=int)
+@click.option("--udp", is_flag=True, help="Check UDP instead of TCP")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.option("--kill", "do_kill", is_flag=True, help="Kill the process using this port")
+@click.option("-f", "--force", is_flag=True, help="Force kill (SIGKILL instead of SIGTERM)")
+@click.option("-y", "--yes", is_flag=True, help="Don't prompt before killing")
+def check(port: int, udp: bool, as_json: bool, do_kill: bool, force: bool, yes: bool):
+    """Check what's using a specific port.
+    
+    Examples:
+        portcheck check 8080
+        portcheck check 8080 --kill
+        portcheck check 8080 --kill -f -y
+        portcheck check 53 --udp
+    """
+    protocol = "udp" if udp else "tcp"
+    results = get_process_on_port(port, protocol)
+    
+    if as_json:
+        click.echo(json.dumps(results, indent=2, default=str))
+        return
+    
+    if not results:
+        click.echo(f"Port {port}/{protocol.upper()} is free")
+        sys.exit(0)
+    
+    for proc in results:
+        pid = proc.get("pid", "unknown")
+        name = proc.get("name", "unknown")
+        user = proc.get("user", "unknown")
+        status = proc.get("status", "unknown")
+        cmdline = proc.get("cmdline", "")
+        
+        click.echo(f"Port {port}/{protocol.upper()} - {status}")
+        click.echo(f"  PID:     {pid}")
+        click.echo(f"  Process: {name}")
+        click.echo(f"  User:    {user}")
+        if cmdline:
+            if len(cmdline) > 80:
+                cmdline = cmdline[:77] + "..."
+            click.echo(f"  Command: {cmdline}")
+        
+        if do_kill and pid and pid != "unknown":
+            if not yes:
+                if not click.confirm(f"Kill process {pid} ({name})?"):
+                    continue
+            
+            action = "Force killing" if force else "Terminating"
+            click.echo(f"  {action} process {pid}...")
+            
+            if kill_process(pid, force):
+                click.secho(f"  ✓ Process {pid} killed", fg="green")
+            else:
+                click.secho(f"  ✗ Failed to kill process {pid}", fg="red")
+                sys.exit(1)
+
+
+@main.command()
+@click.argument("start", type=int)
+@click.argument("end", type=int, required=False)
+@click.option("--udp", is_flag=True, help="Scan UDP instead of TCP")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def scan(start: int, end: Optional[int], udp: bool, as_json: bool):
+    """Scan a range of ports for listeners.
+    
+    Examples:
+        portcheck scan 8000 9000
+        portcheck scan 3000 3100 --json
+    """
+    if end is None:
+        end = start + 100
+    
+    if start > end:
+        start, end = end, start
+    
+    protocol = "udp" if udp else "tcp"
+    results = scan_ports(start, end, protocol)
+    
+    if as_json:
+        click.echo(json.dumps(results, indent=2, default=str))
+        return
+    
+    if not results:
+        click.echo(f"No listeners found on ports {start}-{end}/{protocol.upper()}")
+        return
+    
+    click.echo(f"Listeners on ports {start}-{end}/{protocol.upper()}:")
+    click.echo()
+    
+    for proc in results:
+        port = proc.get("port")
+        pid = proc.get("pid", "?")
+        name = proc.get("name", "unknown")
+        user = proc.get("user", "?")
+        
+        click.echo(f"  {port:5d}  {name:<20} (PID: {pid}, User: {user})")
+
+
+@main.command("list")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.option("--limit", type=int, default=50, help="Max results to show")
+def list_cmd(as_json: bool, limit: int):
+    """List all listening ports.
+    
+    Examples:
+        portcheck list
+        portcheck list --json
+    """
+    # Use lsof on macOS
+    if platform.system() == "Darwin":
+        results = list_listening_lsof()[:limit]
+    else:
+        results = []
+        seen = set()
+        
+        try:
+            for conn in psutil.net_connections(kind="inet"):
+                if conn.status == "LISTEN" and conn.laddr:
+                    if conn.laddr.port not in seen:
+                        seen.add(conn.laddr.port)
+                        proc_info = {
+                            "port": conn.laddr.port,
+                            "address": conn.laddr.ip,
+                            "pid": conn.pid,
+                        }
+                        if conn.pid:
+                            try:
+                                proc = psutil.Process(conn.pid)
+                                proc_info["name"] = proc.name()
+                                proc_info["user"] = proc.username()
+                            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                                pass
+                        results.append(proc_info)
+        except psutil.AccessDenied:
+            results = list_listening_lsof()
+        
+        results = sorted(results, key=lambda x: x["port"])[:limit]
+    
+    if as_json:
+        click.echo(json.dumps(results, indent=2, default=str))
+        return
+    
+    if not results:
+        click.echo("No listening ports found")
+        return
+    
+    click.echo(f"{'PORT':<7} {'ADDRESS':<16} {'PID':<8} {'PROCESS':<20} {'USER'}")
+    click.echo("-" * 65)
+    
+    for r in results:
+        port = r.get("port", "?")
+        addr = r.get("address", "*")
+        pid = r.get("pid", "?")
+        name = r.get("name", "?")[:20] if r.get("name") else "?"
+        user = r.get("user", "?")
+        
+        click.echo(f"{port:<7} {addr:<16} {pid:<8} {name:<20} {user}")
+
+
+@main.command()
+@click.argument("pid", type=int)
+@click.option("-f", "--force", is_flag=True, help="Force kill (SIGKILL)")
+@click.option("-y", "--yes", is_flag=True, help="Don't prompt")
+def kill(pid: int, force: bool, yes: bool):
+    """Kill a process by PID.
+    
+    Examples:
+        portcheck kill 12345
+        portcheck kill 12345 -f -y
+    """
+    try:
+        proc = psutil.Process(pid)
+        name = proc.name()
+    except psutil.NoSuchProcess:
+        click.secho(f"No process with PID {pid}", fg="red")
+        sys.exit(1)
+    except psutil.AccessDenied:
+        name = "unknown"
+    
+    if not yes:
+        if not click.confirm(f"Kill process {pid} ({name})?"):
+            sys.exit(0)
+    
+    action = "Force killing" if force else "Terminating"
+    click.echo(f"{action} process {pid} ({name})...")
+    
+    if kill_process(pid, force):
+        click.secho(f"✓ Process {pid} killed", fg="green")
+    else:
+        click.secho(f"✗ Failed to kill process {pid}", fg="red")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

portcheck_cli-0.1.0/portcheck_cli.egg-info/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: portcheck-cli
+Version: 0.1.0
+Summary: Check what's using a port and optionally kill it
+Author-email: Marcus <marcus.builds.things@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/marcusbuildsthings-droid/portcheck
+Project-URL: Repository, https://github.com/marcusbuildsthings-droid/portcheck
+Keywords: port,network,cli,process,kill,lsof
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: psutil>=5.9
+Dynamic: license-file
+
+# portcheck
+
+Check what's using a port and optionally kill it.
+
+Simple, fast, with JSON output for automation.
+
+## Installation
+
+```bash
+pip install portcheck-cli
+```
+
+## Usage
+
+### Check a specific port
+
+```bash
+# See what's on port 8080
+portcheck check 8080
+
+# Kill whatever's using port 8080
+portcheck check 8080 --kill
+
+# Force kill without confirmation
+portcheck check 8080 --kill -f -y
+
+# Check UDP port
+portcheck check 53 --udp
+
+# Get JSON output
+portcheck check 8080 --json
+```
+
+### Scan a range of ports
+
+```bash
+# Scan ports 8000-9000
+portcheck scan 8000 9000
+
+# Get JSON output
+portcheck scan 3000 3100 --json
+```
+
+### List all listening ports
+
+```bash
+portcheck list
+
+# JSON output
+portcheck list --json
+```
+
+### Kill a process by PID
+
+```bash
+portcheck kill 12345
+portcheck kill 12345 -f -y  # Force, no confirm
+```
+
+## JSON Output
+
+All commands support `--json` for machine-readable output:
+
+```json
+[
+  {
+    "port": 8080,
+    "protocol": "TCP",
+    "status": "LISTEN",
+    "pid": 12345,
+    "local_address": "127.0.0.1:8080",
+    "name": "python",
+    "cmdline": "python -m http.server 8080",
+    "user": "ape"
+  }
+]
+```
+
+## For AI Agents
+
+See [SKILL.md](SKILL.md) for agent-optimized documentation.
+
+## License
+
+MIT

portcheck_cli-0.1.0/portcheck_cli.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+portcheck/__init__.py
+portcheck/cli.py
+portcheck_cli.egg-info/PKG-INFO
+portcheck_cli.egg-info/SOURCES.txt
+portcheck_cli.egg-info/dependency_links.txt
+portcheck_cli.egg-info/entry_points.txt
+portcheck_cli.egg-info/requires.txt
+portcheck_cli.egg-info/top_level.txt

portcheck_cli-0.1.0/portcheck_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

portcheck_cli-0.1.0/portcheck_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+portcheck = portcheck.cli:main

portcheck_cli-0.1.0/portcheck_cli.egg-info/requires.txt

@@ -0,0 +1,2 @@
+click>=8.0
+psutil>=5.9

portcheck_cli-0.1.0/portcheck_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+portcheck

portcheck_cli-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "portcheck-cli"
+version = "0.1.0"
+description = "Check what's using a port and optionally kill it"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "Marcus", email = "marcus.builds.things@gmail.com"}
+]
+keywords = ["port", "network", "cli", "process", "kill", "lsof"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Networking",
+    "Topic :: Utilities",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "click>=8.0",
+    "psutil>=5.9",
+]
+
+[project.urls]
+Homepage = "https://github.com/marcusbuildsthings-droid/portcheck"
+Repository = "https://github.com/marcusbuildsthings-droid/portcheck"
+
+[project.scripts]
+portcheck = "portcheck.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["portcheck*"]

portcheck_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+