pentool 0.2.4__tar.gz → 0.2.5__tar.gz

{pentool-0.2.4 → pentool-0.2.5}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: pentool
-Version: 0.2.4
+Version: 0.2.5
 Summary: Modern Web Pentesting TUI - Professional security testing tool
 Author-email: Pentool Team <dev@pentool.pro>
 License: AGPL-3.0
-Project-URL: Homepage, https://github.com/docxqwerty/pentool
-Project-URL: Repository, https://github.com/docxqwerty/pentool
-Project-URL: Issues, https://github.com/docxqwerty/pentool/issues
-Project-URL: Changelog, https://github.com/docxqwerty/pentool/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/DrXOps/pentool
+Project-URL: Repository, https://github.com/DrXOps/pentool
+Project-URL: Issues, https://github.com/DrXOps/pentool/issues
+Project-URL: Changelog, https://github.com/DrXOps/pentool/blob/main/CHANGELOG.md
 Keywords: pentesting,security,burp,proxy,scanner,intruder
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -50,7 +50,7 @@ Dynamic: license-file
 
 [![PyPI version](https://img.shields.io/pypi/v/pentool)](https://pypi.org/project/pentool/)
 [![Python versions](https://img.shields.io/pypi/pyversions/pentool)](https://pypi.org/project/pentool/)
-[![CI](https://github.com/docxqwerty/pentool/actions/workflows/tests.yml/badge.svg)](https://github.com/docxqwerty/pentool/actions)
+[![CI](https://github.com/DrXOps/pentool/actions/workflows/tests.yml/badge.svg)](https://github.com/DrXOps/pentool/actions)
 [![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](LICENSE)
 [![Downloads](https://img.shields.io/pypi/dm/pentool)](https://pypi.org/project/pentool/)
 
@@ -70,15 +70,15 @@ Fast, transparent, and built for real-world testing.
 
 | Dashboard | Scanner |
 |:---------:|:-------:|
-| ![Dashboard](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/dashboard.png) | ![Scanner](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/scaner.png) |
+| ![Dashboard](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/dashboard.png) | ![Scanner](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/scaner.png) |
 
 | Proxy | Repeater |
 |:-----:|:--------:|
-| ![Proxy](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/proxy.png) | ![Repeater](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/repeater.png) |
+| ![Proxy](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/proxy.png) | ![Repeater](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/repeater.png) |
 
 | Intruder | Settings |
 |:--------:|:--------:|
-| ![Intruder](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/intruder.png) | ![Settings](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/settings.png) |
+| ![Intruder](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/intruder.png) | ![Settings](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/settings.png) |
 
 ---
 
@@ -185,7 +185,7 @@ No minimum follower count. We value quality over reach.
 Pentool is built and maintained by a solo developer in spare time.  
 If it saves you hours on a pentest — consider giving back. Every contribution directly funds new features, fixes, and faster releases.
 
-- ⭐ **[Star on GitHub](https://github.com/docxqwerty/pentool)** — free, takes 2 seconds, helps visibility enormously
+- ⭐ **[Star on GitHub](https://github.com/DrXOps/pentool)** — free, takes 2 seconds, helps visibility enormously
 - 🔑 **PRO license** — get early access and support development → **[@sudores](https://t.me/sudores)**
 - 💬 **Share** — tell a colleague, post a review, or mention Pentool in your writeups
 

{pentool-0.2.4 → pentool-0.2.5}/README.md

@@ -4,7 +4,7 @@
 
 [![PyPI version](https://img.shields.io/pypi/v/pentool)](https://pypi.org/project/pentool/)
 [![Python versions](https://img.shields.io/pypi/pyversions/pentool)](https://pypi.org/project/pentool/)
-[![CI](https://github.com/docxqwerty/pentool/actions/workflows/tests.yml/badge.svg)](https://github.com/docxqwerty/pentool/actions)
+[![CI](https://github.com/DrXOps/pentool/actions/workflows/tests.yml/badge.svg)](https://github.com/DrXOps/pentool/actions)
 [![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](LICENSE)
 [![Downloads](https://img.shields.io/pypi/dm/pentool)](https://pypi.org/project/pentool/)
 
@@ -24,15 +24,15 @@ Fast, transparent, and built for real-world testing.
 
 | Dashboard | Scanner |
 |:---------:|:-------:|
-| ![Dashboard](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/dashboard.png) | ![Scanner](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/scaner.png) |
+| ![Dashboard](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/dashboard.png) | ![Scanner](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/scaner.png) |
 
 | Proxy | Repeater |
 |:-----:|:--------:|
-| ![Proxy](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/proxy.png) | ![Repeater](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/repeater.png) |
+| ![Proxy](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/proxy.png) | ![Repeater](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/repeater.png) |
 
 | Intruder | Settings |
 |:--------:|:--------:|
-| ![Intruder](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/intruder.png) | ![Settings](https://raw.githubusercontent.com/docxqwerty/pentool/main/screens/settings.png) |
+| ![Intruder](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/intruder.png) | ![Settings](https://raw.githubusercontent.com/DrXOps/pentool/main/screens/settings.png) |
 
 ---
 
@@ -139,7 +139,7 @@ No minimum follower count. We value quality over reach.
 Pentool is built and maintained by a solo developer in spare time.  
 If it saves you hours on a pentest — consider giving back. Every contribution directly funds new features, fixes, and faster releases.
 
-- ⭐ **[Star on GitHub](https://github.com/docxqwerty/pentool)** — free, takes 2 seconds, helps visibility enormously
+- ⭐ **[Star on GitHub](https://github.com/DrXOps/pentool)** — free, takes 2 seconds, helps visibility enormously
 - 🔑 **PRO license** — get early access and support development → **[@sudores](https://t.me/sudores)**
 - 💬 **Share** — tell a colleague, post a review, or mention Pentool in your writeups
 

{pentool-0.2.4 → pentool-0.2.5}/pentool/__init__.py

@@ -1,6 +1,6 @@
 """Pentool — professional web security testing toolkit with Textual TUI."""
 
-__version__ = "0.2.4"
+__version__ = "0.2.5"
 __author__ = "pentool"
 
 
@@ -26,6 +26,22 @@ def _bootstrap_pro() -> None:
     every obfuscated PRO module fails to import with
     `ModuleNotFoundError: No module named 'codeenigma_runtime'` even though
     pentool/ itself resolves fine via __path__ extension above.
+
+    The installed (~/.pentool/pro/) PRO package is skipped entirely — not
+    even added to __path__ — if it was built for a different FREE version
+    than this one (core.license.is_pro_package_compatible()). This is the
+    scenario where a FREE upgrade (`pip install --upgrade pentool` /
+    `pentool update`) succeeded but the PRO package's own re-sync
+    afterwards failed or never ran (e.g. offline, or an unrelated version
+    check like the GitHub release lookup errored out first and stopped the
+    whole `pentool update` command before it got to the PRO sync step).
+    Loading a mismatched PRO build there risks a hard-to-diagnose crash: it
+    ships a compiled Cython extension, and an ABI/version mismatch can
+    segfault the process instead of raising a catchable Python exception.
+    The dev `pro/` submodule checkout is never version-mismatched (same
+    source tree as the running FREE code) and is always loaded normally.
+    A warning is printed to stderr so the user isn't left with unexplained
+    missing PRO features and no context.
     """
     import sys
     from pathlib import Path
@@ -33,9 +49,10 @@ def _bootstrap_pro() -> None:
     _pkg_dir = Path(__file__).resolve().parent   # .../pentool/pentool/
     _repo_root = _pkg_dir.parent                 # .../pentool/
 
+    _installed_pro_pkg = Path.home() / ".pentool" / "pro" / "pentool"
     candidates: list[Path] = [
         _repo_root / "pro" / "pentool",                 # dev submodule
-        Path.home() / ".pentool" / "pro" / "pentool",  # installed PRO package
+        _installed_pro_pkg,                              # installed PRO package
     ]
 
     import pentool as _self
@@ -44,6 +61,16 @@ def _bootstrap_pro() -> None:
         if not _pro_pkg.exists():
             continue
 
+        if _pro_pkg == _installed_pro_pkg:
+            try:
+                from pentool.core.license import is_pro_package_compatible
+                _compatible, _warning = is_pro_package_compatible()
+            except Exception:
+                _compatible, _warning = True, ""  # never block startup over this check itself
+            if not _compatible:
+                print(f"[pentool] {_warning}", file=sys.stderr)
+                continue
+
         # 1. Extend top-level pentool.__path__ so that sub-packages
         #    resolved via pkgutil.extend_path below will find pro/pentool/XXX.
         if str(_pro_pkg) not in _self.__path__:

pentool-0.2.5/pentool/__main__.py

@@ -0,0 +1,95 @@
+"""Entry point: no arguments — TUI, with arguments — CLI."""
+
+import sys
+import threading
+
+# Escape hatch for local development: let the TUI start even when the
+# installed PRO package is stale/version-mismatched (see
+# pentool.core.license.is_pro_package_compatible). Intentionally verbose and
+# scary-looking rather than a short flag like "-f" — this bypasses a check
+# that exists specifically because loading a mismatched PRO build can
+# segfault the process, so an accidental/muscle-memory use should be hard.
+# NOT meant for end users — only for developers iterating on FREE-only code
+# who don't want to rebuild/reactivate PRO for every unrelated test run.
+#
+# Note this does NOT force-load the mismatched PRO package itself — that
+# refusal (pentool.__init__._bootstrap_pro) runs unconditionally at import
+# time, before this flag is even parsed, and always prints its own warning
+# when it skips a mismatched PRO install. This flag only bypasses the
+# separate hard stop below that would otherwise refuse to start the TUI at
+# all in that situation — with it, the TUI still starts, just with PRO
+# features unavailable (same as if no PRO package were installed).
+_UNSAFE_SKIP_PRO_CHECK_FLAG = "--unsafe-skip-pro-compat-check"
+
+
+def main() -> None:
+    unsafe_skip_pro_check = _UNSAFE_SKIP_PRO_CHECK_FLAG in sys.argv
+    if unsafe_skip_pro_check:
+        sys.argv.remove(_UNSAFE_SKIP_PRO_CHECK_FLAG)
+
+    if len(sys.argv) > 1:
+        from pentool.cli.main import cli
+        cli()
+    else:
+        # Refuse to start the TUI at all if a PRO package is installed but
+        # was built for a different (or unknown) FREE version — e.g. FREE
+        # was upgraded via `pip install --upgrade pentool` / `pentool
+        # update`, but the PRO package's own re-sync afterwards failed or
+        # never ran (offline, or an unrelated check — like the GitHub
+        # release lookup used for the FREE version check — errored out
+        # first and stopped `pentool update` before it reached the PRO
+        # sync step). The PRO package bundles a compiled Cython extension;
+        # importing a mismatched build can segfault the process with no
+        # log output at all, which is exactly the silent, unexplained
+        # crash this check exists to prevent. Bail out here, before any
+        # Textual app or PRO import is attempted, with a clear message and
+        # a fix instead of a mystery crash.
+        try:
+            from pentool.core.license import is_pro_package_compatible
+            compatible, warning = is_pro_package_compatible()
+        except Exception:
+            compatible, warning = True, ""  # never block startup over this check itself
+
+        if not compatible:
+            if unsafe_skip_pro_check:
+                print(
+                    "[pentool] UNSAFE: --unsafe-skip-pro-compat-check set — "
+                    "starting anyway despite the PRO version mismatch above. "
+                    "PRO features stay disabled (as already reported), but "
+                    "be aware this bypass is unpredictable if anything in "
+                    "this session still ends up touching the mismatched "
+                    "PRO package. Do not use this outside local development.",
+                    file=sys.stderr,
+                )
+            else:
+                print(f"[pentool] {warning}", file=sys.stderr)
+                raise SystemExit(1)
+
+        # Anonymous install-counter ping (fire-and-forget, one increment per
+        # machine — dedup happens server-side). Runs in a background thread —
+        # send_first_run_ping() opens a network connection with an 8s
+        # timeout, which must never delay the TUI actually starting when
+        # the network is slow/unreachable.
+        try:
+            from pentool.core.crash_reporter import send_first_run_ping
+            threading.Thread(target=send_first_run_ping, daemon=True).start()
+        except Exception:
+            pass
+
+        try:
+            from pentool.tui.app import PentoolApp
+            PentoolApp().run()
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception as exc:
+            # Send anonymous crash report (if not disabled in settings)
+            try:
+                from pentool.core.crash_reporter import send_crash
+                send_crash(exc)
+            except Exception:
+                pass
+            raise
+
+
+if __name__ == "__main__":
+    main()

{pentool-0.2.4 → pentool-0.2.5}/pentool/cli/main.py

@@ -110,16 +110,30 @@ def update_cmd(check_only: bool) -> None:
 
     if info.error:
         click.echo(f"Could not check for updates: {info.error}", err=True)
+        # The FREE-version check above failing (network down, GitHub API
+        # rate-limited/404, ...) is unrelated to the PRO package, but it
+        # used to make this command bail out here BEFORE ever reaching
+        # _sync_pro_package_after_upgrade() below — silently leaving an
+        # already-installed PRO package on a stale build with no warning.
+        # Since PRO ships a compiled Cython extension, running a stale
+        # build against a since-upgraded FREE version can segfault the
+        # process with no log output — exactly the "just crashed, no idea
+        # why" report this is meant to prevent. So: still check/warn about
+        # PRO staleness before exiting, even though we can't do the FREE
+        # upgrade itself right now.
+        _warn_if_pro_incompatible()
         raise SystemExit(1)
 
     if not info.has_update:
         click.echo(f"Already up to date (version {info.latest_version}).")
+        _warn_if_pro_incompatible()
         return
 
     click.echo(f"New version available: {info.latest_version}")
     click.echo(f"Release notes: {info.url}")
 
     if check_only:
+        _warn_if_pro_incompatible()
         return
 
     if click.confirm(f"Install {info.latest_version} now?", default=True):
@@ -134,6 +148,25 @@ def update_cmd(check_only: bool) -> None:
                 err=True,
             )
             raise SystemExit(1)
+    else:
+        _warn_if_pro_incompatible()
+
+
+def _warn_if_pro_incompatible() -> None:
+    """Print a warning to the terminal if the installed PRO package (if any)
+    was built for a different FREE version than the one currently running.
+
+    Called from every exit path of `pentool update` that does NOT go through
+    _sync_pro_package_after_upgrade() below — so a user is never left with a
+    stale/incompatible PRO package and zero indication of it, regardless of
+    which branch (FREE check failed, already up to date, --check, declined
+    to install) the command took.
+    """
+    from pentool.core.license import is_pro_package_compatible
+
+    compatible, warning = is_pro_package_compatible()
+    if not compatible:
+        click.echo(f"Warning: {warning}", err=True)
 
 
 def _sync_pro_package_after_upgrade() -> None:
@@ -144,7 +177,10 @@ def _sync_pro_package_after_upgrade() -> None:
     (re)downloaded by check_and_update_pro_package(), which normally runs in
     the background on TUI startup. Doing it here too means a CLI-driven
     upgrade doesn't leave a stale PRO build around until the next TUI launch.
-    Best-effort — never fails the overall upgrade if this part doesn't work.
+    Best-effort for the FREE upgrade's sake — a failure here never raises
+    SystemExit — but always surfaces a warning to the terminal if the PRO
+    package ends up (or remains) incompatible with the just-upgraded FREE
+    version, since that combination risks a crash on next launch.
     """
     import asyncio
 
@@ -155,11 +191,14 @@ def _sync_pro_package_after_upgrade() -> None:
 
     try:
         click.echo("Checking for a newer PRO build...")
-        updated = asyncio.run(check_and_update_pro_package())
-        if updated:
+        result = asyncio.run(check_and_update_pro_package())
+        if result.updated:
             click.echo("PRO package updated to the latest build.")
+        elif result.warning:
+            click.echo(f"Warning: {result.warning}", err=True)
     except Exception as exc:
         click.echo(f"Could not check for a PRO update: {exc}", err=True)
+        _warn_if_pro_incompatible()
 
 
 @cli.group()

{pentool-0.2.4 → pentool-0.2.5}/pentool/core/license.py

@@ -503,13 +503,131 @@ def _current_platform() -> str:
     return "linux"
 
 
-# File recording which PRO build is currently unpacked into PRO_PACKAGE_DIR —
-# lets check_and_update_pro_package() tell "same build as last time" apart
-# from "a new build was published" without re-downloading the archive to
-# compare it. See _fetch_pro_build_id() / /api/pro/version on the Worker.
+# File recording which PRO build is currently unpacked into PRO_PACKAGE_DIR,
+# together with the FREE (pip) pentool version it was downloaded for — lets
+# check_and_update_pro_package() tell "same build as last time" apart from "a
+# new build was published" without re-downloading the archive to compare it,
+# and lets is_pro_package_compatible() detect a FREE/PRO version mismatch.
+# See _fetch_pro_build_id() / /api/pro/version on the Worker.
+_PRO_META_FILE = PRO_PACKAGE_DIR / ".build_meta.json"
+
+# Legacy pre-2026-08 marker: plain text build_id, no version recorded. Still
+# read (as "unknown version" -> treated as incompatible/stale, see
+# is_pro_package_compatible()) so an old install isn't mistaken for corrupt.
 _PRO_BUILD_MARKER = PRO_PACKAGE_DIR / ".build_id"
 
 
+@dataclass
+class ProSyncResult:
+    """Outcome of a check_and_update_pro_package() call.
+
+    `warning` is meant to be shown to the user verbatim (TUI notify / CLI
+    stderr) whenever the locally installed PRO package is stale or was built
+    for a different FREE version than the one currently running — silently
+    running on a mismatched PRO package is what risks a hard crash (it ships
+    a compiled Cython extension; an ABI/version mismatch there can segfault
+    instead of raising a catchable Python exception).
+    """
+    updated: bool = False
+    warning: str = ""
+
+
+def _read_pro_meta() -> dict:
+    """Read the PRO package's build metadata (build_id + the FREE pentool
+    version it was downloaded for). Falls back to the legacy plain-text
+    .build_id file with an empty free_version if the JSON meta file isn't
+    there yet — is_pro_package_compatible() then correctly treats that as
+    "unknown version, don't trust it" rather than crashing on missing data.
+    """
+    try:
+        if _PRO_META_FILE.exists():
+            data = json.loads(_PRO_META_FILE.read_text(encoding="utf-8"))
+            if isinstance(data, dict):
+                return data
+    except Exception:
+        pass
+    try:
+        if _PRO_BUILD_MARKER.exists():
+            return {"build_id": _PRO_BUILD_MARKER.read_text(encoding="utf-8").strip(), "free_version": ""}
+    except Exception:
+        pass
+    return {}
+
+
+def _write_pro_meta(build_id: str) -> None:
+    """Record which build_id is now unpacked, and which FREE version it was
+    fetched for — called right after a successful extract in
+    download_pro_package()."""
+    try:
+        from pentool import __version__ as free_version
+    except Exception:
+        free_version = ""
+    try:
+        _PRO_META_FILE.write_text(
+            json.dumps({"build_id": build_id, "free_version": free_version}),
+            encoding="utf-8",
+        )
+        _PRO_BUILD_MARKER.unlink(missing_ok=True)  # migrate off the legacy marker
+    except Exception:
+        pass
+
+
+def is_pro_package_compatible() -> tuple[bool, str]:
+    """Check whether the PRO package in PRO_PACKAGE_DIR matches the FREE
+    (pip) version of pentool currently running.
+
+    This is the guard against a stale/incompatible PRO package: the FREE
+    package updates via `pip install --upgrade pentool`, but the PRO package
+    (a separately downloaded, platform-specific compiled Cython extension)
+    only updates when check_and_update_pro_package() successfully reaches
+    the server — e.g. `pentool update`'s own version-check step failing
+    (network down, GitHub 404, ...) does NOT stop the FREE upgrade, but DOES
+    leave PRO on its old build. Loading that mismatched PRO build can
+    segfault the whole process instead of raising a catchable exception,
+    so every call site that would otherwise import from the PRO package
+    (plugin_manager, __init__._bootstrap_pro) checks this FIRST and refuses
+    to load it rather than relying on try/except around the import.
+
+    Returns:
+        (True, "") — nothing installed, or the installed PRO package matches
+            the running FREE version.
+        (False, message) — a PRO package is installed but was built for a
+            different (or unknown) FREE version. `message` is a
+            user-facing explanation of what to do.
+    """
+    if not PRO_PACKAGE_DIR.exists():
+        return True, ""
+
+    try:
+        from pentool import __version__ as current_version
+    except Exception:
+        current_version = ""
+
+    meta = _read_pro_meta()
+    pro_free_version = meta.get("free_version", "")
+
+    if not pro_free_version:
+        return False, (
+            "A PRO package is installed, but its build metadata doesn't record "
+            "which Pentool version it was built for (a previous PRO update "
+            "likely didn't finish). PRO features are disabled to avoid a "
+            "crash from a version mismatch — run "
+            "'pentool license activate <key>' to re-download the PRO package."
+        )
+
+    if pro_free_version != current_version:
+        return False, (
+            f"Version mismatch: Pentool {current_version} is installed, but "
+            f"the PRO package was built for version {pro_free_version}. "
+            f"Running it as-is could crash the app. PRO features are "
+            f"disabled until this is resynced — run "
+            f"'pentool license activate <key>' or wait for the background "
+            f"PRO update to complete."
+        )
+
+    return True, ""
+
+
 async def download_pro_package(key: str, machine_id: str) -> bool:
     """Download, verify, and install the obfuscated PRO package.
 
@@ -562,13 +680,15 @@ async def download_pro_package(key: str, machine_id: str) -> bool:
         finally:
             tmp_archive.unlink(missing_ok=True)
 
-        # Record which build this is, so a later check_and_update_pro_package()
-        # can tell "nothing changed" from "a new build was published" without
-        # re-downloading the archive just to compare it.
+        # Record which build this is (and which FREE version it was fetched
+        # for — see is_pro_package_compatible()), so a later
+        # check_and_update_pro_package() can tell "nothing changed" from "a
+        # new build was published" without re-downloading the archive just
+        # to compare it.
         try:
             build_id = await _fetch_pro_build_id(plat)
             if build_id:
-                _PRO_BUILD_MARKER.write_text(build_id, encoding="utf-8")
+                _write_pro_meta(build_id)
         except Exception:
             pass  # non-fatal — worst case, next check just re-downloads once more
 
@@ -604,8 +724,9 @@ async def _fetch_pro_build_id(plat: str) -> str | None:
         return None
 
 
-async def check_and_update_pro_package() -> bool:
-    """Re-download the PRO package if a newer build has been published.
+async def check_and_update_pro_package() -> "ProSyncResult":
+    """Re-download the PRO package if a newer build has been published, or if
+    the currently-installed one no longer matches the running FREE version.
 
     Called on TUI startup (background worker, same pattern as
     _check_for_updates for the pip package) and after `pentool update` — this
@@ -614,33 +735,51 @@ async def check_and_update_pro_package() -> bool:
     ~/.pentool/pro/ forever, because download_pro_package() otherwise only
     ever runs once, at initial activation/trial-start.
 
-    Silently does nothing (returns False) if:
-      - there's no active PRO license (nothing to update)
-      - the PRO package was never downloaded in the first place (that's
-        activate_license's job, not this one)
-      - the version check or download fails for any reason
-
-    Returns True if a new build was found and successfully installed.
+    Crucially, this is also the ONLY place that re-syncs PRO after a FREE
+    upgrade (`pip install --upgrade pentool` / `pentool update`) — if this
+    step can't reach the license server (network down, or the *unrelated*
+    FREE-side GitHub version check already failed and the caller never even
+    got here), the PRO package silently stays on its old build while FREE
+    moves on. Since the PRO package ships a compiled Cython extension, that
+    mismatch can segfault the process instead of raising a Python exception.
+    So on every "couldn't sync" path below, this now also checks
+    is_pro_package_compatible() and returns a non-empty `warning` if the
+    installed PRO build is stale/unknown — callers (TUI, CLI) must surface
+    that warning to the user rather than silently doing nothing.
+
+    Returns a ProSyncResult:
+      - updated=True  — a new build was found and successfully installed.
+      - updated=False, warning=""    — nothing to do (no PRO license, PRO
+        never installed, or already on the latest compatible build).
+      - updated=False, warning="..." — could not verify/refresh the PRO
+        package AND the installed one is stale or version-mismatched;
+        `warning` is a user-facing message to display.
     """
     info = get_license()
     if not info.valid or not info.features:
-        return False
+        return ProSyncResult(updated=False, warning="")
     if not PRO_PACKAGE_DIR.exists():
-        return False  # never activated on this machine — nothing to refresh
+        return ProSyncResult(updated=False, warning="")  # never activated — nothing to refresh
 
     plat = _current_platform()
     remote_build_id = await _fetch_pro_build_id(plat)
     if not remote_build_id:
-        return False  # couldn't reach the server — don't touch anything
+        # Couldn't reach the server to check — don't touch the package, but
+        # DO tell the user if what's on disk is already known-stale/mismatched.
+        _compatible, warning = is_pro_package_compatible()
+        return ProSyncResult(updated=False, warning=warning)
 
-    local_build_id = None
-    try:
-        if _PRO_BUILD_MARKER.exists():
-            local_build_id = _PRO_BUILD_MARKER.read_text(encoding="utf-8").strip()
-    except Exception:
-        pass
+    meta = _read_pro_meta()
+    local_build_id = meta.get("build_id", "")
 
     if local_build_id == remote_build_id:
-        return False  # already on the latest build
+        _compatible, warning = is_pro_package_compatible()
+        return ProSyncResult(updated=False, warning=warning)
+
+    updated = await download_pro_package(info.license_key, info.machine_id)
+    if updated:
+        return ProSyncResult(updated=True, warning="")
 
-    return await download_pro_package(info.license_key, info.machine_id)
+    # Download of the newer build failed — warn if what's left on disk is stale.
+    _compatible, warning = is_pro_package_compatible()
+    return ProSyncResult(updated=False, warning=warning)

{pentool-0.2.4 → pentool-0.2.5}/pentool/core/plugin_manager.py

@@ -161,6 +161,12 @@ class PluginManager:
         self._passive_checks: list[type[BaseCheck]] = []
         self._loaded: list[str] = []
         self._meta: list[PluginMeta] = []
+        # Set by load_user_plugins() when a PRO package is present on disk
+        # but was built for a different (or unknown) FREE version — see
+        # pentool.core.license.is_pro_package_compatible(). Empty string
+        # means no incompatibility was detected. Callers (TUI startup, CLI)
+        # should surface this to the user rather than silently ignoring it.
+        self.pro_incompatible_warning: str = ""
 
     # ── Loading ───────────────────────────────────────────────────────────────
 
@@ -197,7 +203,21 @@ class PluginManager:
         # Obfuscated PRO package downloaded via 'pentool license trial'/'activate'
         # (see pentool.core.license.download_pro_package). Its plugins directory
         # mirrors the builtin layout: pro/pentool/plugins/builtin/*.py
-        from pentool.core.license import PRO_PACKAGE_DIR
+        #
+        # Refuse to import it if it was built for a different FREE version
+        # than the one currently running (e.g. FREE was upgraded via
+        # `pip install --upgrade pentool` but the PRO re-sync afterwards
+        # failed/never ran) — the PRO package bundles a compiled Cython
+        # extension, and importing a mismatched build there can segfault the
+        # whole process instead of raising a catchable Python exception. See
+        # pentool.core.license.is_pro_package_compatible().
+        from pentool.core.license import PRO_PACKAGE_DIR, is_pro_package_compatible
+        compatible, warning = is_pro_package_compatible()
+        if not compatible:
+            logger.warning("PRO package skipped — %s", warning)
+            self.pro_incompatible_warning = warning
+            return
+
         pro_plugins_dir = PRO_PACKAGE_DIR / "pentool" / "plugins" / "builtin"
         if pro_plugins_dir.exists():
             self.load_plugins([str(pro_plugins_dir)], warn_untrusted=False)
@@ -360,11 +380,24 @@ def load_pro_module(module_stem: str):
     Raises FileNotFoundError if the module isn't found in any known PRO
     location (dev submodule or installed package) — callers should show
     this to the user instead of silently failing.
+
+    Raises RuntimeError if the installed PRO package (PRO_PACKAGE_DIR) was
+    built for a different FREE version than the one currently running — see
+    pentool.core.license.is_pro_package_compatible(). Refusing to import it
+    is deliberate: it's a compiled Cython extension, and importing a
+    mismatched build can segfault the process instead of raising a
+    catchable Python exception. Does NOT apply to the dev `pro/` submodule
+    checkout, which is always the same source tree as the running FREE code.
     """
     module_name = f"_pentool_plugin_{module_stem}"
     if module_name in sys.modules:
         return sys.modules[module_name]
 
+    from pentool.core.license import PRO_PACKAGE_DIR, is_pro_package_compatible
+    compatible, warning = is_pro_package_compatible()
+    if not compatible:
+        raise RuntimeError(warning)
+
     for plugin_dir in _candidate_pro_builtin_dirs():
         candidate = plugin_dir / f"{module_stem}.py"
         if not candidate.exists():