nibble-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{nibble_cli-0.3.0 → nibble_cli-0.4.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: nibble-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: Fast local network scanner with hardware identification and a terminal UI
 Home-page: https://github.com/backendsystems/nibble
 Author: saberd
-Author-email: your-email@example.com
+Author-email: mail@saberd.com
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: System Administrators

nibble_cli-0.4.0/nibble_cli/checksum.py

@@ -0,0 +1,50 @@
+import hashlib
+
+
+def get_checksum(text, archive_name):
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        parts = line.split()
+        if len(parts) < 2:
+            continue
+        checksum = parts[0].lower()
+        filename = parts[-1].lstrip("*")
+        if filename == archive_name:
+            return checksum
+    return None
+
+
+def sha256_file(path):
+    with open(path, "rb") as f:
+        return hashlib.sha256(f.read()).hexdigest()
+
+
+def verify_release_checksum(base_url, project, version, archive_name, archive_path, download_text):
+    checksum_candidates = [
+        "checksums.txt",
+        f"{project}_{version}_checksums.txt",
+    ]
+
+    checksum_text = None
+    checksum_name = None
+    for candidate in checksum_candidates:
+        text = download_text(f"{base_url}/{candidate}")
+        if text is not None:
+            checksum_text = text
+            checksum_name = candidate
+            break
+
+    if checksum_text is None:
+        raise RuntimeError(
+            f"no checksum file found for v{version} (tried: {', '.join(checksum_candidates)})"
+        )
+
+    expected = get_checksum(checksum_text, archive_name)
+    if expected is None:
+        raise RuntimeError(f"checksum for {archive_name} not found in {checksum_name}")
+
+    actual = sha256_file(archive_path)
+    if actual != expected:
+        raise RuntimeError(f"checksum mismatch for {archive_name}")

nibble_cli-0.4.0/nibble_cli/cleanup.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import shutil
+import sys
+from importlib import metadata
+from pathlib import Path
+
+PROJECT = "nibble"
+DIST_NAME = "nibble-cli"
+
+
+def cache_root():
+    if os.name == "nt":
+        base = Path(os.environ.get("LOCALAPPDATA", str(Path.home())))
+    else:
+        base = Path.home() / ".local" / "share"
+    return base / PROJECT
+
+
+def installed_version():
+    try:
+        version = metadata.version(DIST_NAME)
+    except metadata.PackageNotFoundError:
+        return None
+    return version[1:] if version.startswith("v") else version
+
+
+def remove_path(path):
+    if not path.exists():
+        return False
+    shutil.rmtree(path)
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Clean cached nibble binaries.")
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Remove all cached nibble versions.",
+    )
+    args = parser.parse_args()
+
+    root = cache_root()
+    if args.all:
+        removed = remove_path(root)
+        if removed:
+            print(f"Removed cache: {root}")
+        else:
+            print(f"No cache found at: {root}")
+        return 0
+
+    version = installed_version()
+    if version is None:
+        print("nibble-cli is not installed. Use --all to remove cache root.", file=sys.stderr)
+        return 1
+
+    target = root / version
+    removed = remove_path(target)
+    if removed:
+        print(f"Removed cache for v{version}: {target}")
+    else:
+        print(f"No cache found for v{version}: {target}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

nibble_cli-0.4.0/nibble_cli/download.py

@@ -0,0 +1,24 @@
+import shutil
+import urllib.error
+import urllib.request
+
+
+def download_asset(url, out_path):
+    try:
+        with urllib.request.urlopen(url) as resp, open(out_path, "wb") as f:
+            shutil.copyfileobj(resp, f)
+        return True
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return False
+        raise
+
+
+def download_text(url):
+    try:
+        with urllib.request.urlopen(url) as resp:
+            return resp.read().decode("utf-8", errors="replace")
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return None
+        raise

nibble_cli-0.4.0/nibble_cli/install.py

@@ -0,0 +1,117 @@
+import os
+import platform
+import shutil
+import tarfile
+import tempfile
+from importlib import metadata
+from pathlib import Path
+
+from nibble_cli.checksum import verify_release_checksum
+from nibble_cli.download import download_asset, download_text
+
+OWNER = "backendsystems"
+PROJECT = "nibble"
+DIST_NAME = "nibble-cli"
+
+
+def platform_triplet():
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    os_map = {
+        "linux": "linux",
+        "darwin": "darwin",
+        "windows": "windows",
+    }
+    arch_map = {
+        "x86_64": "amd64",
+        "amd64": "amd64",
+        "aarch64": "arm64",
+        "arm64": "arm64",
+    }
+
+    os_name = os_map.get(system)
+    arch = arch_map.get(machine)
+    if not os_name or not arch:
+        raise RuntimeError(f"unsupported platform: system={system}, arch={machine}")
+    return os_name, arch
+
+
+def install_dir():
+    if os.name == "nt":
+        base = Path(os.environ.get("LOCALAPPDATA", str(Path.home())))
+    else:
+        base = Path.home() / ".local" / "share"
+    path = base / PROJECT
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def dist_version():
+    version = metadata.version(DIST_NAME)
+    return version[1:] if version.startswith("v") else version
+
+
+def binary_name():
+    return f"{PROJECT}.exe" if os.name == "nt" else PROJECT
+
+
+def release_base(version):
+    return f"https://github.com/{OWNER}/{PROJECT}/releases/download/v{version}"
+
+
+def extract_binary(archive_path, dest_binary):
+    wanted = {binary_name(), PROJECT, f"{PROJECT}.exe"}
+
+    with tarfile.open(archive_path, "r:*") as tf:
+        member = next(
+            (m for m in tf.getmembers() if m.isfile() and Path(m.name).name in wanted),
+            None,
+        )
+        if member is None:
+            raise RuntimeError("binary not found inside release archive")
+
+        src = tf.extractfile(member)
+        if src is None:
+            raise RuntimeError("failed to extract binary from release archive")
+
+        with src, open(dest_binary, "wb") as dst:
+            shutil.copyfileobj(src, dst)
+
+
+def ensure_installed():
+    version = dist_version()
+    os_name, arch = platform_triplet()
+
+    # Keep binaries in a versioned local cache directory.
+    install_root = install_dir()
+    binary_path = install_root / version / "bin" / binary_name()
+    binary_path.parent.mkdir(parents=True, exist_ok=True)
+    if binary_path.exists():
+        return binary_path
+
+    asset = f"{PROJECT}_{os_name}_{arch}.tar.gz"
+    release_url = release_base(version)
+    archive_url = f"{release_url}/{asset}"
+
+    with tempfile.TemporaryDirectory() as tmp:
+        # Download and verify the release asset before extracting it.
+        archive_path = Path(tmp) / asset
+        if not download_asset(archive_url, archive_path):
+            raise RuntimeError(
+                f"release asset not found for {os_name}/{arch} at v{version}: {asset}"
+            )
+        verify_release_checksum(
+            base_url=release_url,
+            project=PROJECT,
+            version=version,
+            archive_name=asset,
+            archive_path=archive_path,
+            download_text=download_text,
+        )
+        # Extract the nibble binary from the archive into the cache path.
+        extract_binary(archive_path, binary_path)
+
+    if os.name != "nt":
+        binary_path.chmod(0o755)
+    return binary_path

nibble_cli-0.4.0/nibble_cli/installer.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+import subprocess
+import sys
+
+from nibble_cli.install import ensure_installed
+
+
+def main():
+    try:
+        binary = ensure_installed()
+    except Exception as e:
+        print(f"nibble install error: {e}", file=sys.stderr)
+        return 1
+
+    result = subprocess.run([str(binary)] + sys.argv[1:])
+    return result.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{nibble_cli-0.3.0 → nibble_cli-0.4.0}/nibble_cli.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: nibble-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: Fast local network scanner with hardware identification and a terminal UI
 Home-page: https://github.com/backendsystems/nibble
 Author: saberd
-Author-email: your-email@example.com
+Author-email: mail@saberd.com
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: System Administrators

nibble_cli-0.4.0/nibble_cli.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+setup.py
+nibble_cli/__init__.py
+nibble_cli/checksum.py
+nibble_cli/cleanup.py
+nibble_cli/download.py
+nibble_cli/install.py
+nibble_cli/installer.py
+nibble_cli.egg-info/PKG-INFO
+nibble_cli.egg-info/SOURCES.txt
+nibble_cli.egg-info/dependency_links.txt
+nibble_cli.egg-info/entry_points.txt
+nibble_cli.egg-info/top_level.txt

nibble_cli-0.4.0/nibble_cli.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+nibble = nibble_cli.installer:main
+nibble-cleanup = nibble_cli.cleanup:main

nibble_cli-0.4.0/nibble_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+nibble_cli

{nibble_cli-0.3.0 → nibble_cli-0.4.0}/setup.py

@@ -1,4 +1,4 @@
-from setuptools import setup
+from setuptools import find_packages, setup
 import os
 import subprocess
 
@@ -21,12 +21,13 @@ setup(
     long_description=open("README.md").read() if os.path.exists("README.md") else "",
     long_description_content_type="text/markdown",
     author="saberd",
-    author_email="your-email@example.com",
+    author_email="mail@saberd.com",
     url="https://github.com/backendsystems/nibble",
-    py_modules=["nibble_installer"],
+    packages=find_packages(),
     entry_points={
         "console_scripts": [
-            "nibble=nibble_installer:main",
+            "nibble=nibble_cli.installer:main",
+            "nibble-cleanup=nibble_cli.cleanup:main",
         ],
     },
     install_requires=[],

nibble_cli-0.3.0/nibble_cli.egg-info/SOURCES.txt

@@ -1,7 +0,0 @@
-nibble_installer.py
-setup.py
-nibble_cli.egg-info/PKG-INFO
-nibble_cli.egg-info/SOURCES.txt
-nibble_cli.egg-info/dependency_links.txt
-nibble_cli.egg-info/entry_points.txt
-nibble_cli.egg-info/top_level.txt

nibble_cli-0.3.0/nibble_cli.egg-info/entry_points.txt

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

nibble_cli-0.3.0/nibble_cli.egg-info/top_level.txt

@@ -1 +0,0 @@
-nibble_installer

nibble_cli-0.3.0/nibble_installer.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-"""
-Nibble CLI wrapper for pip.
-Downloads the matching GitHub Release binary and executes it.
-"""
-
-import os
-import platform
-import shutil
-import subprocess
-import sys
-import tarfile
-import tempfile
-import urllib.error
-import urllib.request
-import zipfile
-from importlib import metadata
-from pathlib import Path
-
-REPO = "backendsystems/nibble"
-PROJECT = "nibble"
-DIST_NAME = "nibble-cli"
-
-
-def _platform_triplet():
-    system = platform.system().lower()
-    machine = platform.machine().lower()
-
-    os_map = {
-        "linux": "linux",
-        "darwin": "darwin",
-        "windows": "windows",
-    }
-    arch_map = {
-        "x86_64": "amd64",
-        "amd64": "amd64",
-        "aarch64": "arm64",
-        "arm64": "arm64",
-    }
-
-    os_name = os_map.get(system)
-    arch = arch_map.get(machine)
-    if not os_name or not arch:
-        raise RuntimeError(f"unsupported platform: system={system}, arch={machine}")
-    return os_name, arch
-
-
-def _install_dir():
-    if os.name == "nt":
-        base = Path(os.environ.get("LOCALAPPDATA", str(Path.home())))
-    else:
-        base = Path.home() / ".local" / "share"
-    path = base / PROJECT
-    path.mkdir(parents=True, exist_ok=True)
-    return path
-
-
-def _dist_version():
-    version = metadata.version(DIST_NAME)
-    return version[1:] if version.startswith("v") else version
-
-
-def _binary_name():
-    return f"{PROJECT}.exe" if os.name == "nt" else PROJECT
-
-
-def _download_asset(url, out_path):
-    try:
-        with urllib.request.urlopen(url) as resp, open(out_path, "wb") as f:
-            shutil.copyfileobj(resp, f)
-        return True
-    except urllib.error.HTTPError as e:
-        if e.code == 404:
-            return False
-        raise
-
-
-def _extract_binary(archive_path, dest_binary):
-    bin_names = {_binary_name(), PROJECT, f"{PROJECT}.exe"}
-
-    if str(archive_path).endswith(".zip"):
-        with zipfile.ZipFile(archive_path, "r") as zf:
-            for member in zf.namelist():
-                name = Path(member).name
-                if name in bin_names:
-                    with zf.open(member) as src, open(dest_binary, "wb") as dst:
-                        shutil.copyfileobj(src, dst)
-                    return
-    else:
-        with tarfile.open(archive_path, "r:*") as tf:
-            for member in tf.getmembers():
-                if not member.isfile():
-                    continue
-                name = Path(member.name).name
-                if name in bin_names:
-                    src = tf.extractfile(member)
-                    if src is None:
-                        continue
-                    with src, open(dest_binary, "wb") as dst:
-                        shutil.copyfileobj(src, dst)
-                    return
-
-    raise RuntimeError("binary not found inside release archive")
-
-
-def ensure_installed():
-    install_dir = _install_dir()
-    version = _dist_version()
-    version_dir = install_dir / version / "bin"
-    version_dir.mkdir(parents=True, exist_ok=True)
-    binary_path = version_dir / _binary_name()
-    if binary_path.exists():
-        return binary_path
-
-    os_name, arch = _platform_triplet()
-    asset_base = f"{PROJECT}_{os_name}_{arch}"
-    candidates = [f"{asset_base}.tar.gz", f"{asset_base}.zip"]
-
-    with tempfile.TemporaryDirectory() as tmp:
-        tmpdir = Path(tmp)
-        archive_path = None
-        for asset in candidates:
-            url = f"https://github.com/{REPO}/releases/download/v{version}/{asset}"
-            local = tmpdir / asset
-            if _download_asset(url, local):
-                archive_path = local
-                break
-        if archive_path is None:
-            raise RuntimeError(
-                f"no release asset found for {os_name}/{arch} at v{version} (tried: {', '.join(candidates)})"
-            )
-
-        _extract_binary(archive_path, binary_path)
-
-    if os.name != "nt":
-        binary_path.chmod(0o755)
-    return binary_path
-
-
-def main():
-    try:
-        binary = ensure_installed()
-    except Exception as e:
-        print(f"nibble install error: {e}", file=sys.stderr)
-        return 1
-
-    result = subprocess.run([str(binary)] + sys.argv[1:])
-    return result.returncode
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())