netcheck-cli 0.1.0__tar.gz

netcheck_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.

netcheck_cli-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: netcheck-cli
+Version: 0.1.0
+Summary: Network diagnostics CLI — DNS, ping, HTTP check, SSL certs, latency
+Author-email: Marcus <marcus.builds.things@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/marcusbuildsthings-droid/netcheck
+Project-URL: Issues, https://github.com/marcusbuildsthings-droid/netcheck/issues
+Keywords: network,dns,ping,ssl,diagnostics,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Dynamic: license-file
+
+# netcheck-cli
+
+Network diagnostics from the command line — DNS lookup, ping, HTTP check, SSL cert info, latency, port scan, and IP lookup.
+
+## Install
+
+```bash
+pip install netcheck-cli
+```
+
+## Usage
+
+```bash
+# DNS lookup
+netcheck dns example.com
+netcheck dns example.com --type MX
+
+# Ping
+netcheck ping example.com -c 4
+
+# HTTP endpoint check
+netcheck http https://example.com
+netcheck http api.example.com --method HEAD
+
+# SSL certificate info
+netcheck cert example.com
+netcheck cert example.com --port 8443
+
+# TCP latency measurement
+netcheck latency example.com -n 10
+
+# Port scan
+netcheck scan example.com -p 80,443,8080
+
+# Public + local IP
+netcheck ip
+```
+
+All commands support `--json` for machine-readable output:
+
+```bash
+netcheck --json dns example.com
+netcheck --json cert example.com
+```
+
+## For AI Agents
+
+See [SKILL.md](SKILL.md) for agent-optimized documentation.
+
+## License
+
+MIT

netcheck_cli-0.1.0/README.md

@@ -0,0 +1,52 @@
+# netcheck-cli
+
+Network diagnostics from the command line — DNS lookup, ping, HTTP check, SSL cert info, latency, port scan, and IP lookup.
+
+## Install
+
+```bash
+pip install netcheck-cli
+```
+
+## Usage
+
+```bash
+# DNS lookup
+netcheck dns example.com
+netcheck dns example.com --type MX
+
+# Ping
+netcheck ping example.com -c 4
+
+# HTTP endpoint check
+netcheck http https://example.com
+netcheck http api.example.com --method HEAD
+
+# SSL certificate info
+netcheck cert example.com
+netcheck cert example.com --port 8443
+
+# TCP latency measurement
+netcheck latency example.com -n 10
+
+# Port scan
+netcheck scan example.com -p 80,443,8080
+
+# Public + local IP
+netcheck ip
+```
+
+All commands support `--json` for machine-readable output:
+
+```bash
+netcheck --json dns example.com
+netcheck --json cert example.com
+```
+
+## For AI Agents
+
+See [SKILL.md](SKILL.md) for agent-optimized documentation.
+
+## License
+
+MIT

netcheck_cli-0.1.0/netcheck/__init__.py

@@ -0,0 +1,2 @@
+"""netcheck-cli — Network diagnostics from the command line."""
+__version__ = "0.1.0"

netcheck_cli-0.1.0/netcheck/cli.py

@@ -0,0 +1,391 @@
+"""netcheck-cli — Network diagnostics CLI."""
+import click
+import json as _json
+import socket
+import ssl
+import subprocess
+import sys
+import time
+import urllib.request
+import urllib.error
+from datetime import datetime, timezone
+
+
+def _out(data, as_json):
+    if as_json:
+        click.echo(_json.dumps(data, indent=2, default=str))
+    else:
+        for k, v in data.items():
+            if isinstance(v, list):
+                click.echo(f"  {k}:")
+                for item in v:
+                    click.echo(f"    - {item}")
+            elif isinstance(v, dict):
+                click.echo(f"  {k}:")
+                for sk, sv in v.items():
+                    click.echo(f"    {sk}: {sv}")
+            else:
+                click.echo(f"  {k}: {v}")
+
+
+@click.group()
+@click.option("--json", "as_json", is_flag=True, help="JSON output")
+@click.pass_context
+def cli(ctx, as_json):
+    """Network diagnostics CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj["json"] = as_json
+
+
+@cli.command()
+@click.argument("hostname")
+@click.option("--type", "record_type", default="A", help="Record type (A, AAAA, MX, etc.)")
+@click.pass_context
+def dns(ctx, hostname, record_type):
+    """DNS lookup for a hostname."""
+    as_json = ctx.obj["json"]
+    result = {"hostname": hostname, "type": record_type}
+    try:
+        if record_type.upper() in ("A", "AAAA"):
+            family = socket.AF_INET if record_type.upper() == "A" else socket.AF_INET6
+            try:
+                addrs = socket.getaddrinfo(hostname, None, family, socket.SOCK_STREAM)
+                ips = sorted(set(a[4][0] for a in addrs))
+            except socket.gaierror:
+                ips = []
+            result["addresses"] = ips
+            result["count"] = len(ips)
+            if not as_json:
+                click.echo(f"DNS {record_type} lookup: {hostname}")
+                if ips:
+                    for ip in ips:
+                        click.echo(f"  {ip}")
+                else:
+                    click.echo("  No records found")
+                return
+        else:
+            # Use dig/nslookup for other record types
+            try:
+                out = subprocess.run(
+                    ["dig", "+short", hostname, record_type.upper()],
+                    capture_output=True, text=True, timeout=10
+                )
+                records = [l.strip() for l in out.stdout.strip().split("\n") if l.strip()]
+                result["records"] = records
+                result["count"] = len(records)
+                if not as_json:
+                    click.echo(f"DNS {record_type} lookup: {hostname}")
+                    for r in records:
+                        click.echo(f"  {r}")
+                    if not records:
+                        click.echo("  No records found")
+                    return
+            except FileNotFoundError:
+                result["error"] = "dig not found; install bind/dnsutils for non-A/AAAA lookups"
+                if not as_json:
+                    click.echo(f"Error: {result['error']}", err=True)
+                    sys.exit(1)
+    except Exception as e:
+        result["error"] = str(e)
+        if not as_json:
+            click.echo(f"Error: {e}", err=True)
+            sys.exit(1)
+    if as_json:
+        click.echo(_json.dumps(result, indent=2))
+
+
+@cli.command()
+@click.argument("host")
+@click.option("-c", "--count", default=4, help="Number of pings")
+@click.option("-t", "--timeout", default=5, help="Timeout per ping (seconds)")
+@click.pass_context
+def ping(ctx, host, count, timeout):
+    """Ping a host."""
+    as_json = ctx.obj["json"]
+    try:
+        out = subprocess.run(
+            ["ping", "-c", str(count), "-W", str(timeout * 1000), host],
+            capture_output=True, text=True, timeout=count * timeout + 5
+        )
+        lines = out.stdout.strip().split("\n")
+        # Parse stats from last two lines
+        result = {"host": host, "count": count, "output": lines, "returncode": out.returncode}
+
+        # Try to parse summary
+        for line in lines:
+            if "packets transmitted" in line.lower() or "received" in line.lower():
+                result["summary"] = line.strip()
+            if "min/avg/max" in line or "round-trip" in line:
+                result["rtt"] = line.strip()
+
+        if as_json:
+            click.echo(_json.dumps(result, indent=2))
+        else:
+            click.echo(out.stdout)
+            if out.returncode != 0 and out.stderr:
+                click.echo(out.stderr, err=True)
+    except subprocess.TimeoutExpired:
+        msg = f"Ping to {host} timed out"
+        if as_json:
+            click.echo(_json.dumps({"host": host, "error": msg}))
+        else:
+            click.echo(msg, err=True)
+        sys.exit(1)
+    except Exception as e:
+        if as_json:
+            click.echo(_json.dumps({"host": host, "error": str(e)}))
+        else:
+            click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("url")
+@click.option("--method", default="GET", help="HTTP method")
+@click.option("--timeout", default=10, help="Timeout in seconds")
+@click.option("--follow/--no-follow", default=True, help="Follow redirects")
+@click.pass_context
+def http(ctx, url, method, timeout, follow):
+    """Check HTTP endpoint status."""
+    as_json = ctx.obj["json"]
+    if not url.startswith("http"):
+        url = "https://" + url
+
+    result = {"url": url, "method": method}
+    start = time.monotonic()
+    try:
+        req = urllib.request.Request(url, method=method)
+        req.add_header("User-Agent", "netcheck-cli/0.1.0")
+
+        if not follow:
+            opener = urllib.request.build_opener(urllib.request.HTTPHandler, urllib.request.HTTPSHandler)
+        else:
+            opener = urllib.request.build_opener()
+
+        resp = opener.open(req, timeout=timeout)
+        elapsed = time.monotonic() - start
+        result["status"] = resp.status
+        result["reason"] = resp.reason
+        result["latency_ms"] = round(elapsed * 1000, 1)
+        result["headers"] = dict(resp.headers)
+        result["final_url"] = resp.url
+        result["ok"] = True
+
+        if not as_json:
+            click.echo(f"HTTP {method} {url}")
+            click.echo(f"  Status: {resp.status} {resp.reason}")
+            click.echo(f"  Latency: {result['latency_ms']}ms")
+            if resp.url != url:
+                click.echo(f"  Redirected: {resp.url}")
+            ct = resp.headers.get("Content-Type", "")
+            if ct:
+                click.echo(f"  Content-Type: {ct}")
+            server = resp.headers.get("Server", "")
+            if server:
+                click.echo(f"  Server: {server}")
+    except urllib.error.HTTPError as e:
+        elapsed = time.monotonic() - start
+        result["status"] = e.code
+        result["reason"] = e.reason
+        result["latency_ms"] = round(elapsed * 1000, 1)
+        result["ok"] = False
+        if not as_json:
+            click.echo(f"HTTP {method} {url}")
+            click.echo(f"  Status: {e.code} {e.reason}")
+            click.echo(f"  Latency: {result['latency_ms']}ms")
+    except Exception as e:
+        elapsed = time.monotonic() - start
+        result["error"] = str(e)
+        result["latency_ms"] = round(elapsed * 1000, 1)
+        result["ok"] = False
+        if not as_json:
+            click.echo(f"HTTP {method} {url}")
+            click.echo(f"  Error: {e}")
+            click.echo(f"  Latency: {result['latency_ms']}ms")
+            sys.exit(1)
+
+    if as_json:
+        click.echo(_json.dumps(result, indent=2))
+
+
+@cli.command()
+@click.argument("hostname")
+@click.option("--port", default=443, help="Port to connect to")
+@click.pass_context
+def cert(ctx, hostname, port):
+    """Check SSL/TLS certificate for a hostname."""
+    as_json = ctx.obj["json"]
+    result = {"hostname": hostname, "port": port}
+    try:
+        context = ssl.create_default_context()
+        with socket.create_connection((hostname, port), timeout=10) as sock:
+            with context.wrap_socket(sock, server_hostname=hostname) as ssock:
+                cert_info = ssock.getpeercert()
+                result["subject"] = dict(x[0] for x in cert_info.get("subject", ()))
+                result["issuer"] = dict(x[0] for x in cert_info.get("issuer", ()))
+                result["serial"] = cert_info.get("serialNumber", "")
+                result["version"] = cert_info.get("version", "")
+                result["notBefore"] = cert_info.get("notBefore", "")
+                result["notAfter"] = cert_info.get("notAfter", "")
+                result["protocol"] = ssock.version()
+
+                # Parse expiry
+                try:
+                    expiry = datetime.strptime(cert_info["notAfter"], "%b %d %H:%M:%S %Y %Z")
+                    expiry = expiry.replace(tzinfo=timezone.utc)
+                    days_left = (expiry - datetime.now(timezone.utc)).days
+                    result["days_until_expiry"] = days_left
+                    result["expired"] = days_left < 0
+                except Exception:
+                    pass
+
+                # SANs
+                sans = []
+                for type_val in cert_info.get("subjectAltName", ()):
+                    sans.append(f"{type_val[0]}:{type_val[1]}")
+                result["san"] = sans
+
+                if not as_json:
+                    cn = result["subject"].get("commonName", "N/A")
+                    issuer_cn = result["issuer"].get("commonName", "N/A")
+                    click.echo(f"SSL Certificate: {hostname}:{port}")
+                    click.echo(f"  Common Name: {cn}")
+                    click.echo(f"  Issuer: {issuer_cn}")
+                    click.echo(f"  Valid: {result['notBefore']} → {result['notAfter']}")
+                    if "days_until_expiry" in result:
+                        days = result["days_until_expiry"]
+                        status = "⚠️ EXPIRED" if days < 0 else f"✅ {days} days left" if days > 30 else f"⚠️ {days} days left"
+                        click.echo(f"  Expiry: {status}")
+                    click.echo(f"  Protocol: {result['protocol']}")
+                    if sans:
+                        click.echo(f"  SANs: {', '.join(s.split(':',1)[1] for s in sans[:5])}")
+                        if len(sans) > 5:
+                            click.echo(f"    ... and {len(sans)-5} more")
+    except ssl.SSLCertVerificationError as e:
+        result["error"] = str(e)
+        result["valid"] = False
+        if not as_json:
+            click.echo(f"SSL Certificate: {hostname}:{port}")
+            click.echo(f"  ❌ Verification failed: {e}")
+    except Exception as e:
+        result["error"] = str(e)
+        if not as_json:
+            click.echo(f"SSL Certificate: {hostname}:{port}")
+            click.echo(f"  Error: {e}")
+            sys.exit(1)
+
+    if as_json:
+        click.echo(_json.dumps(result, indent=2))
+
+
+@cli.command()
+@click.argument("host")
+@click.option("-p", "--port", default=443, help="Port to check")
+@click.option("-n", "--count", default=5, help="Number of connections")
+@click.pass_context
+def latency(ctx, host, port, count):
+    """Measure TCP connection latency to host:port."""
+    as_json = ctx.obj["json"]
+    times = []
+    errors = 0
+    for _ in range(count):
+        start = time.monotonic()
+        try:
+            with socket.create_connection((host, port), timeout=5):
+                elapsed = (time.monotonic() - start) * 1000
+                times.append(round(elapsed, 2))
+        except Exception:
+            errors += 1
+        time.sleep(0.1)
+
+    result = {
+        "host": host,
+        "port": port,
+        "count": count,
+        "successful": len(times),
+        "errors": errors,
+    }
+    if times:
+        result["min_ms"] = min(times)
+        result["max_ms"] = max(times)
+        result["avg_ms"] = round(sum(times) / len(times), 2)
+        result["times_ms"] = times
+
+    if as_json:
+        click.echo(_json.dumps(result, indent=2))
+    else:
+        click.echo(f"TCP latency: {host}:{port} ({count} connections)")
+        if times:
+            click.echo(f"  Min: {result['min_ms']}ms")
+            click.echo(f"  Avg: {result['avg_ms']}ms")
+            click.echo(f"  Max: {result['max_ms']}ms")
+        if errors:
+            click.echo(f"  Errors: {errors}/{count}")
+        if not times:
+            click.echo("  All connections failed")
+            sys.exit(1)
+
+
+@cli.command()
+@click.argument("host")
+@click.option("-p", "--ports", default="22,80,443,3000,5000,8080,8443", help="Comma-separated ports")
+@click.option("-t", "--timeout", default=2, help="Timeout per port (seconds)")
+@click.pass_context
+def scan(ctx, host, ports, timeout):
+    """Quick port scan on common ports."""
+    as_json = ctx.obj["json"]
+    port_list = [int(p.strip()) for p in ports.split(",")]
+    results = []
+    for port in port_list:
+        try:
+            with socket.create_connection((host, port), timeout=timeout):
+                results.append({"port": port, "state": "open"})
+        except (ConnectionRefusedError, OSError):
+            results.append({"port": port, "state": "closed"})
+        except socket.timeout:
+            results.append({"port": port, "state": "filtered"})
+
+    if as_json:
+        click.echo(_json.dumps({"host": host, "ports": results}, indent=2))
+    else:
+        click.echo(f"Port scan: {host}")
+        for r in results:
+            icon = "✅" if r["state"] == "open" else "❌" if r["state"] == "closed" else "⏳"
+            click.echo(f"  {icon} {r['port']:>5} {r['state']}")
+
+
+@cli.command()
+@click.pass_context
+def ip(ctx):
+    """Show public and local IP addresses."""
+    as_json = ctx.obj["json"]
+    result = {}
+
+    # Local IP
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        result["local_ip"] = s.getsockname()[0]
+        s.close()
+    except Exception:
+        result["local_ip"] = None
+
+    # Public IP
+    try:
+        req = urllib.request.Request("https://api.ipify.org?format=json")
+        req.add_header("User-Agent", "netcheck-cli/0.1.0")
+        resp = urllib.request.urlopen(req, timeout=5)
+        data = _json.loads(resp.read())
+        result["public_ip"] = data.get("ip")
+    except Exception:
+        result["public_ip"] = None
+
+    if as_json:
+        click.echo(_json.dumps(result, indent=2))
+    else:
+        click.echo(f"  Local IP:  {result.get('local_ip', 'unknown')}")
+        click.echo(f"  Public IP: {result.get('public_ip', 'unknown')}")
+
+
+if __name__ == "__main__":
+    cli()

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

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: netcheck-cli
+Version: 0.1.0
+Summary: Network diagnostics CLI — DNS, ping, HTTP check, SSL certs, latency
+Author-email: Marcus <marcus.builds.things@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/marcusbuildsthings-droid/netcheck
+Project-URL: Issues, https://github.com/marcusbuildsthings-droid/netcheck/issues
+Keywords: network,dns,ping,ssl,diagnostics,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Dynamic: license-file
+
+# netcheck-cli
+
+Network diagnostics from the command line — DNS lookup, ping, HTTP check, SSL cert info, latency, port scan, and IP lookup.
+
+## Install
+
+```bash
+pip install netcheck-cli
+```
+
+## Usage
+
+```bash
+# DNS lookup
+netcheck dns example.com
+netcheck dns example.com --type MX
+
+# Ping
+netcheck ping example.com -c 4
+
+# HTTP endpoint check
+netcheck http https://example.com
+netcheck http api.example.com --method HEAD
+
+# SSL certificate info
+netcheck cert example.com
+netcheck cert example.com --port 8443
+
+# TCP latency measurement
+netcheck latency example.com -n 10
+
+# Port scan
+netcheck scan example.com -p 80,443,8080
+
+# Public + local IP
+netcheck ip
+```
+
+All commands support `--json` for machine-readable output:
+
+```bash
+netcheck --json dns example.com
+netcheck --json cert example.com
+```
+
+## For AI Agents
+
+See [SKILL.md](SKILL.md) for agent-optimized documentation.
+
+## License
+
+MIT

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

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

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1 @@
+click>=8.0

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

@@ -0,0 +1 @@
+netcheck

netcheck_cli-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "netcheck-cli"
+version = "0.1.0"
+description = "Network diagnostics CLI — DNS, ping, HTTP check, SSL certs, latency"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [{name = "Marcus", email = "marcus.builds.things@gmail.com"}]
+keywords = ["network", "dns", "ping", "ssl", "diagnostics", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Networking",
+    "Topic :: Utilities",
+]
+dependencies = ["click>=8.0"]
+
+[project.scripts]
+netcheck = "netcheck.cli:cli"
+
+[project.urls]
+Homepage = "https://github.com/marcusbuildsthings-droid/netcheck"
+Issues = "https://github.com/marcusbuildsthings-droid/netcheck/issues"

netcheck_cli-0.1.0/setup.cfg

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