evo-cli 0.11.1__tar.gz → 0.11.2__tar.gz

{evo_cli-0.11.1 → evo_cli-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.11.1
+Version: 0.11.2
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

evo_cli-0.11.2/evo_cli/VERSION

@@ -0,0 +1 @@
+0.11.2

{evo_cli-0.11.1 → evo_cli-0.11.2}/evo_cli/cli.py

@@ -6,6 +6,8 @@ from evo_cli.commands.cloudflare import cfssh
 from evo_cli.commands.fix_claude import f_claude
 from evo_cli.commands.gdrive import gdrive
 from evo_cli.commands.gh import setup_gh
+from evo_cli.commands.hwid import hwid
+from evo_cli.commands.hwid_reset import hwid_reset
 from evo_cli.commands.localproxy import localproxy
 from evo_cli.commands.mcp import mcp_group
 from evo_cli.commands.miniconda import miniconda
@@ -54,6 +56,8 @@ cli.add_command(setup_group)
 cli.add_command(cfssh)
 cli.add_command(f_claude)
 cli.add_command(gdrive)
+cli.add_command(hwid)
+cli.add_command(hwid_reset)
 cli.add_command(site2s)
 cli.add_command(localproxy)
 cli.add_command(mcp_group)

evo_cli-0.11.2/evo_cli/commands/hwid.py

@@ -0,0 +1,237 @@
+import hashlib
+import json as jsonlib
+import platform
+import re
+import subprocess
+import sys
+import uuid
+
+import rich_click as click
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from evo_cli.console import console, error, info, step
+
+# Each identifier: (key, human label, contributes to the composite HWID hash).
+# Only stable, hard-to-change identifiers feed the hash; disk serial and MAC
+# are shown for reference but excluded (disks get swapped, MACs are plural).
+ID_SPECS = [
+    ("machine_guid", "Machine GUID", True),
+    ("system_uuid", "System UUID", True),
+    ("board_serial", "Baseboard serial", True),
+    ("bios_serial", "BIOS serial", True),
+    ("cpu_id", "CPU ID", True),
+    ("disk_serial", "Disk serial", False),
+    ("mac", "MAC address", False),
+]
+
+# Placeholder strings firmware vendors leave in serial fields - useless as IDs.
+JUNK_VALUES = {
+    "",
+    "0",
+    "none",
+    "n/a",
+    "na",
+    "null",
+    "to be filled by o.e.m.",
+    "to be filled by o.e.m",
+    "default string",
+    "system serial number",
+    "system product name",
+    "system uuid",
+    "00000000-0000-0000-0000-000000000000",
+    "ffffffff-ffff-ffff-ffff-ffffffffffff",
+    "0123456789",
+}
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo hwid[/cyan]                  show hardware identifiers and the composite HWID\n"
+    "  [cyan]evo hwid --json[/cyan]           machine-readable output\n"
+    "  [cyan]evo hwid --raw[/cyan]            also print the pre-hash composite string\n"
+    "  [cyan]evo hwid --salt myapp[/cyan]     namespace the HWID for a specific app/license\n\n"
+    "[dim]The HWID is a SHA-256 over the stable identifiers that are present\n"
+    "(machine GUID, system UUID, baseboard / BIOS serial, CPU ID). It stays\n"
+    "constant across reboots and reinstalls on the same physical machine.[/dim]"
+)
+
+
+def _run(cmd, timeout=10):
+    """Run a command, return stdout on success, else None (never raises)."""
+    try:
+        out = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return out.stdout if out.returncode == 0 else None
+
+
+def _clean(value):
+    """Normalise a raw identifier; drop firmware placeholder junk to None."""
+    if value is None:
+        return None
+    value = str(value).strip()
+    if value.lower() in JUNK_VALUES:
+        return None
+    return value or None
+
+
+def _read_file(path):
+    try:
+        with open(path) as handle:
+            return handle.read().strip()
+    except OSError:
+        return None
+
+
+def _mac_address():
+    """Primary NIC MAC as AA:BB:CC:DD:EE:FF, or None if unavailable/random."""
+    node = uuid.getnode()
+    # getnode() sets the multicast bit when it has to invent a random address.
+    if (node >> 40) & 0x1:
+        return None
+    return ":".join(f"{(node >> shift) & 0xFF:02X}" for shift in range(40, -1, -8))
+
+
+# --- per-platform collection -------------------------------------------------
+_PS_SCRIPT = (
+    "$ErrorActionPreference='SilentlyContinue';"
+    "[pscustomobject]@{"
+    "machine_guid=(Get-ItemProperty 'HKLM:\\SOFTWARE\\Microsoft\\Cryptography' -Name MachineGuid).MachineGuid;"
+    "system_uuid=(Get-CimInstance Win32_ComputerSystemProduct).UUID;"
+    "board_serial=(Get-CimInstance Win32_BaseBoard).SerialNumber;"
+    "bios_serial=(Get-CimInstance Win32_BIOS).SerialNumber;"
+    "cpu_id=(Get-CimInstance Win32_Processor | Select-Object -First 1).ProcessorId;"
+    "disk_serial=(Get-CimInstance Win32_DiskDrive | Select-Object -First 1).SerialNumber"
+    "} | ConvertTo-Json -Compress"
+)
+
+
+def _collect_windows(ids):
+    out = _run(["powershell", "-NoProfile", "-NonInteractive", "-Command", _PS_SCRIPT])
+    if out:
+        try:
+            parsed = jsonlib.loads(out)
+        except (ValueError, TypeError):
+            parsed = {}
+        for key in ("machine_guid", "system_uuid", "board_serial", "bios_serial", "cpu_id", "disk_serial"):
+            ids[key] = _clean(parsed.get(key))
+
+
+def _collect_darwin(ids):
+    out = _run(["ioreg", "-rd1", "-c", "IOPlatformExpertDevice"])
+    if out:
+        uuid_match = re.search(r'"IOPlatformUUID"\s*=\s*"([^"]+)"', out)
+        serial_match = re.search(r'"IOPlatformSerialNumber"\s*=\s*"([^"]+)"', out)
+        ids["system_uuid"] = _clean(uuid_match.group(1) if uuid_match else None)
+        ids["board_serial"] = _clean(serial_match.group(1) if serial_match else None)
+
+
+def _collect_linux(ids):
+    ids["machine_guid"] = _clean(_read_file("/etc/machine-id") or _read_file("/var/lib/dbus/machine-id"))
+    # DMI fields under /sys; product_uuid and board_serial usually need root.
+    ids["system_uuid"] = _clean(_read_file("/sys/class/dmi/id/product_uuid"))
+    ids["board_serial"] = _clean(_read_file("/sys/class/dmi/id/board_serial"))
+    ids["bios_serial"] = _clean(_read_file("/sys/class/dmi/id/product_serial"))
+
+
+def collect():
+    system = platform.system()
+    ids = {key: None for key, _, _ in ID_SPECS}
+    if system == "Windows":
+        _collect_windows(ids)
+    elif system == "Darwin":
+        _collect_darwin(ids)
+    elif system == "Linux":
+        _collect_linux(ids)
+    ids["mac"] = _mac_address()
+    return system, ids
+
+
+# --- composite HWID ----------------------------------------------------------
+def compute_hwid(ids, salt=None):
+    used = [key for key, _, in_hash in ID_SPECS if in_hash and ids.get(key)]
+    if not used:
+        return None, None, None, used
+    composite = "|".join(ids[key] for key in used)
+    raw = f"{salt}|{composite}" if salt else composite
+    digest = hashlib.sha256(raw.encode("utf-8")).hexdigest().upper()
+    return digest, digest[:16], composite, used
+
+
+# --- rendering ---------------------------------------------------------------
+def render(system, ids, hwid, short, composite, used, show_raw):
+    table = Table(title="Hardware identifiers", title_style="accent", show_header=True, header_style="accent")
+    table.add_column("Identifier", style="info", no_wrap=True)
+    table.add_column("Value", style="default", overflow="fold")
+    table.add_column("In HWID", justify="center", no_wrap=True)
+
+    for key, label, in_hash in ID_SPECS:
+        value = ids.get(key)
+        value_cell = value if value else "[dim]unavailable[/dim]"
+        if in_hash:
+            mark = "[success]yes[/success]" if value else "[dim]-[/dim]"
+        else:
+            mark = "[dim]no[/dim]"
+        table.add_row(label, value_cell, mark)
+    console.print(table)
+    console.print(f"[dim]platform: {system or 'unknown'}[/dim]")
+
+    step("HWID")
+    if not hwid:
+        error("No stable hardware identifier could be read on this machine.")
+        info("On Linux, system UUID and board serial usually need root (try with sudo).")
+        return
+
+    if show_raw:
+        console.print(f"[dim]composite:[/dim] {composite}")
+    console.print(
+        Panel(
+            f"[bold accent]{hwid}[/bold accent]\n[dim]short:[/dim] [accent]{short}[/accent]",
+            title="HWID (SHA-256)",
+            border_style="accent",
+            expand=False,
+        )
+    )
+    console.print(f"[dim]derived from: {', '.join(used)}[/dim]")
+
+
+@click.command("hwid", epilog=EPILOG)
+@click.option("--salt", "salt", default=None, help="Namespace the HWID with an app/license string before hashing.")
+@click.option("--raw", "show_raw", is_flag=True, help="Also print the pre-hash composite string.")
+@click.option("--json", "as_json", is_flag=True, help="Print result as JSON.")
+def hwid(salt, show_raw, as_json):
+    """Show this machine's hardware ID (HWID).
+
+    Reads the stable hardware identifiers available on the current platform -
+    **machine GUID**, **system UUID**, **baseboard / BIOS serial** and **CPU
+    ID** - then folds them into a single **SHA-256 composite HWID** that stays
+    constant across reboots and OS reinstalls on the same physical machine.
+
+    Disk serial and MAC address are shown for reference but kept out of the hash
+    (disks get replaced, machines have several MACs). Use `--salt` to derive a
+    per-application HWID, and `--json` for machine-readable output.
+    """
+    try:
+        system, ids = collect()
+        hwid_value, short, composite, used = compute_hwid(ids, salt)
+
+        if as_json:
+            payload = {
+                "platform": system,
+                "identifiers": ids,
+                "salt": salt,
+                "components": used,
+                "hwid": hwid_value,
+                "hwid_short": short,
+            }
+            console.print_json(jsonlib.dumps(payload, ensure_ascii=False))
+            return
+
+        step("evo hwid")
+        render(system, ids, hwid_value, short, composite, used, show_raw)
+    except click.ClickException:
+        raise
+    except Exception as exc:
+        error(str(exc))
+        sys.exit(1)

evo_cli-0.11.2/evo_cli/commands/hwid_reset.py

@@ -0,0 +1,197 @@
+import os
+import platform
+import sys
+import uuid
+
+import rich_click as click
+from rich.text import Text
+
+from evo_cli.console import console, error, info, step, success, warning
+
+# Only the OS-generated machine identifier is rotated here. Firmware / hardware
+# identifiers (system UUID, baseboard / BIOS serial, CPU ID) live in SMBIOS and
+# are read-only from software, so they are left untouched - see the docstring.
+LINUX_MACHINE_ID = "/etc/machine-id"
+LINUX_DBUS_MACHINE_ID = "/var/lib/dbus/machine-id"
+WIN_CRYPTO_KEY = r"SOFTWARE\Microsoft\Cryptography"
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo hwid-reset[/cyan]                  generate a new machine identifier (asks first)\n"
+    "  [cyan]evo hwid-reset --dry-run[/cyan]        preview the change without writing anything\n"
+    "  [cyan]evo hwid-reset -y[/cyan]               apply without the confirmation prompt\n"
+    "  [cyan]evo hwid-reset --set <guid>[/cyan]     restore a specific value you saved earlier\n\n"
+    "[dim]Only the OS-level identifier is rotated: the Windows Machine GUID\n"
+    "(HKLM\\SOFTWARE\\Microsoft\\Cryptography) or the Linux machine-id. Firmware\n"
+    "identifiers (system UUID, board / BIOS serial, CPU ID) are read-only and stay\n"
+    "the same, so 'evo hwid' will change only in its machine_guid component.\n"
+    "Needs Administrator (Windows) or root (Linux). Save the old value to restore it.[/dim]"
+)
+
+
+def _normalize_guid(value):
+    """Validate/normalise a Windows Machine GUID to lowercase, no braces."""
+    try:
+        return str(uuid.UUID(value.strip().strip("{}")))
+    except (ValueError, AttributeError):
+        raise click.BadParameter(f"not a valid GUID: {value}")
+
+
+def _normalize_machine_id(value):
+    """Validate/normalise a Linux machine-id to 32 lowercase hex chars."""
+    cleaned = value.strip().lower().replace("-", "")
+    try:
+        return uuid.UUID(cleaned).hex
+    except ValueError:
+        raise click.BadParameter(f"not a valid machine-id: {value}")
+
+
+# --- Windows -----------------------------------------------------------------
+def _win_is_admin():
+    import ctypes
+
+    try:
+        return bool(ctypes.windll.shell32.IsUserAnAdmin())
+    except (AttributeError, OSError):
+        return False
+
+
+def _win_read_guid():
+    import winreg
+
+    try:
+        key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, WIN_CRYPTO_KEY, 0, winreg.KEY_READ | winreg.KEY_WOW64_64KEY)
+        try:
+            value, _ = winreg.QueryValueEx(key, "MachineGuid")
+            return value
+        finally:
+            winreg.CloseKey(key)
+    except OSError:
+        return None
+
+
+def _win_write_guid(value):
+    import winreg
+
+    key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, WIN_CRYPTO_KEY, 0, winreg.KEY_SET_VALUE | winreg.KEY_WOW64_64KEY)
+    try:
+        winreg.SetValueEx(key, "MachineGuid", 0, winreg.REG_SZ, value)
+    finally:
+        winreg.CloseKey(key)
+
+
+def reset_windows(set_value, dry_run, assume_yes):
+    old = _win_read_guid()
+    new = _normalize_guid(set_value) if set_value else str(uuid.uuid4())
+
+    info(r"Machine GUID - HKLM\SOFTWARE\Microsoft\Cryptography\MachineGuid")
+    console.print(f"  [dim]old:[/dim] {old or '[dim]unavailable[/dim]'}")
+    console.print(f"  [accent]new:[/accent] {new}")
+
+    if dry_run:
+        info("dry-run: nothing was changed.")
+        return
+    if not _win_is_admin():
+        error("Administrator privileges are required. Re-run evo from an elevated terminal.")
+        sys.exit(1)
+    if not assume_yes and not click.confirm("Write the new Machine GUID now?", default=False):
+        info("aborted - nothing changed.")
+        return
+
+    try:
+        _win_write_guid(new)
+    except PermissionError:
+        error("Access denied writing the registry. Run from an elevated (Administrator) terminal.")
+        sys.exit(1)
+    success("Machine GUID updated.")
+    if old:
+        warning(f"To restore the previous value: evo hwid-reset --set {old}")
+    info("Run 'evo hwid' to see the new composite HWID.")
+
+
+# --- Linux -------------------------------------------------------------------
+def _read(path):
+    try:
+        with open(path) as handle:
+            return handle.read().strip()
+    except OSError:
+        return None
+
+
+def reset_linux(set_value, dry_run, assume_yes):
+    old = _read(LINUX_MACHINE_ID)
+    new = _normalize_machine_id(set_value) if set_value else uuid.uuid4().hex
+
+    info(f"machine-id - {LINUX_MACHINE_ID} (and {LINUX_DBUS_MACHINE_ID})")
+    console.print(f"  [dim]old:[/dim] {old or '[dim]unavailable[/dim]'}")
+    console.print(f"  [accent]new:[/accent] {new}")
+
+    if dry_run:
+        info("dry-run: nothing was changed.")
+        return
+    if os.geteuid() != 0:
+        error("Root privileges are required. Re-run with sudo.")
+        sys.exit(1)
+    if not assume_yes and not click.confirm("Write the new machine-id now?", default=False):
+        info("aborted - nothing changed.")
+        return
+
+    try:
+        for path in (LINUX_MACHINE_ID, LINUX_DBUS_MACHINE_ID):
+            if path == LINUX_DBUS_MACHINE_ID and not os.path.exists(os.path.dirname(path)):
+                continue
+            with open(path, "w") as handle:
+                handle.write(new + "\n")
+    except OSError as exc:
+        error(f"Failed to write machine-id: {exc}")
+        sys.exit(1)
+    success("machine-id updated.")
+    if old:
+        warning(f"To restore the previous value: evo hwid-reset --set {old}")
+    info("A reboot is recommended so all services pick up the new machine-id.")
+    info("Run 'evo hwid' to see the new composite HWID.")
+
+
+# --- macOS -------------------------------------------------------------------
+def reset_darwin():
+    warning("macOS has no software-writable machine identifier to reset.")
+    info("The system UUID and hardware serial are stored in firmware and are read-only.")
+
+
+@click.command("hwid-reset", epilog=EPILOG)
+@click.option("--set", "set_value", default=None, help="Set an explicit value instead of generating one.")
+@click.option("--dry-run", "dry_run", is_flag=True, help="Show what would change without modifying anything.")
+@click.option("-y", "--yes", "assume_yes", is_flag=True, help="Skip the confirmation prompt.")
+def hwid_reset(set_value, dry_run, assume_yes):
+    """Reset this machine's OS-level hardware identifier.
+
+    Rotates the only identifier that software can legitimately regenerate: the
+    **Windows Machine GUID** (`HKLM\\SOFTWARE\\Microsoft\\Cryptography`) or the
+    **Linux machine-id** (`/etc/machine-id`). This is the same operation Windows
+    `sysprep` and `systemd-machine-id-setup` perform when a machine is cloned
+    from an image.
+
+    Firmware and hardware identifiers used by `evo hwid` - **system UUID**,
+    **baseboard / BIOS serial** and **CPU ID** - live in SMBIOS and are read-only
+    from software, so they are left unchanged; only the `machine_guid` component
+    of the composite HWID changes. The old value is printed so you can restore it
+    with `--set`. Requires Administrator (Windows) or root (Linux); use
+    `--dry-run` to preview.
+    """
+    step("evo hwid-reset")
+    system = platform.system()
+    try:
+        if system == "Windows":
+            reset_windows(set_value, dry_run, assume_yes)
+        elif system == "Linux":
+            reset_linux(set_value, dry_run, assume_yes)
+        elif system == "Darwin":
+            reset_darwin()
+        else:
+            error(f"Unsupported platform: {system or 'unknown'}")
+            sys.exit(1)
+    except click.ClickException:
+        raise
+    except Exception as exc:
+        error(str(exc))
+        sys.exit(1)

{evo_cli-0.11.1 → evo_cli-0.11.2}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.11.1
+Version: 0.11.2
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

{evo_cli-0.11.1 → evo_cli-0.11.2}/evo_cli.egg-info/SOURCES.txt

@@ -23,6 +23,8 @@ evo_cli/commands/cloudflare.py
 evo_cli/commands/fix_claude.py
 evo_cli/commands/gdrive.py
 evo_cli/commands/gh.py
+evo_cli/commands/hwid.py
+evo_cli/commands/hwid_reset.py
 evo_cli/commands/localproxy.py
 evo_cli/commands/mcp.py
 evo_cli/commands/miniconda.py

evo_cli-0.11.1/evo_cli/VERSION

@@ -1 +0,0 @@
-0.11.1