nexo-brain 7.25.1 → 7.25.3

package/bin/nexo-brain.js

@@ -57,6 +57,8 @@ const DEFAULT_ASSISTANT_NAME = "Nova";
 const RESERVED_ASSISTANT_NAME_KEYS = new Set(["nexo", "nexobrain", "nexodesktop"]);
 const MIN_INSTALLER_PYTHON_MAJOR = 3;
 const MIN_INSTALLER_PYTHON_MINOR = 10;
+const DESKTOP_BUNDLED_WHEEL_PYTHON_MAJOR = 3;
+const DESKTOP_BUNDLED_WHEEL_PYTHON_MINOR = 12;
 
 function normalizeAssistantNameCandidate(value) {
   return String(value || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
@@ -278,11 +280,25 @@ function pythonVersionMeetsMinimum(versionText) {
     || (major === MIN_INSTALLER_PYTHON_MAJOR && minor >= MIN_INSTALLER_PYTHON_MINOR);
 }
 
+function pythonVersionMatchesDesktopBundle(versionText) {
+  const match = String(versionText || "").trim().match(/^(\d+)\.(\d+)(?:\.|$)/);
+  if (!match) return false;
+  return Number(match[1]) === DESKTOP_BUNDLED_WHEEL_PYTHON_MAJOR
+    && Number(match[2]) === DESKTOP_BUNDLED_WHEEL_PYTHON_MINOR;
+}
+
+function pythonVersionUsableForInstaller(versionText) {
+  if (!pythonVersionMeetsMinimum(versionText)) return false;
+  if (isDesktopManagedInstall()) return pythonVersionMatchesDesktopBundle(versionText);
+  return true;
+}
+
 function resolveInstallerPython() {
   const candidates = [
     process.env.NEXO_BOOTSTRAP_PYTHON,
     process.env.NEXO_RUNTIME_PYTHON,
     process.env.NEXO_PYTHON,
+    run("which python3.12"),
     run("which python3"),
     run("which python"),
   ].filter(Boolean);
@@ -292,7 +308,7 @@ function resolveInstallerPython() {
     if (!clean || seen.has(clean)) continue;
     seen.add(clean);
     const version = pythonVersion(clean);
-    if (version && pythonVersionMeetsMinimum(version)) return clean;
+    if (version && pythonVersionUsableForInstaller(version)) return clean;
   }
   return "";
 }
@@ -366,9 +382,11 @@ function uniqueBackupPath(targetPath, suffix) {
 function ensureManagedVenvCompatible(venvPath, venvPython) {
   if (!fs.existsSync(venvPython)) return;
   const version = pythonVersion(venvPython);
-  if (version && pythonVersionMeetsMinimum(version)) return;
+  if (version && pythonVersionUsableForInstaller(version)) return;
 
-  const reason = version ? `Python ${version}` : "an unreadable Python executable";
+  const reason = version
+    ? `Python ${version}${isDesktopManagedInstall() ? " (Desktop bundle requires Python 3.12)" : ""}`
+    : "an unreadable Python executable";
   const backupPath = uniqueBackupPath(venvPath, "unsupported-python");
   log(`  Existing Python virtual environment uses ${reason}; moving it aside to recreate.`);
   try {
@@ -3300,14 +3318,14 @@ async function runSetup() {
     }
     if (!python) {
       log("Python 3 not found and couldn't install automatically.");
-      log(platform === "darwin" ? "Install it: brew install python3" : "Install it: sudo apt install python3");
+      log(platform === "darwin" ? "Install it: brew install python@3.12" : "Install it: sudo apt install python3");
       process.exit(1);
     }
   }
   const pyVersion = pythonVersion(python);
-  if (!pyVersion || !pythonVersionMeetsMinimum(pyVersion)) {
+  if (!pyVersion || !pythonVersionUsableForInstaller(pyVersion)) {
     log(pyVersion
-      ? `Python at ${python} is ${pyVersion}; NEXO Brain requires Python >=${MIN_INSTALLER_PYTHON_MAJOR}.${MIN_INSTALLER_PYTHON_MINOR}.`
+      ? `Python at ${python} is ${pyVersion}; NEXO Brain requires ${isDesktopManagedInstall() ? "Python 3.12 for Desktop bundled wheels" : `Python >=${MIN_INSTALLER_PYTHON_MAJOR}.${MIN_INSTALLER_PYTHON_MINOR}`}.`
       : `Python at ${python || "(not found)"} is not executable.`);
     process.exit(1);
   }
@@ -3618,7 +3636,7 @@ async function runSetup() {
   }
   if (fs.existsSync(venvPython)) {
     const venvVersion = pythonVersion(venvPython);
-    if (!venvVersion || !pythonVersionMeetsMinimum(venvVersion)) {
+    if (!venvVersion || !pythonVersionUsableForInstaller(venvVersion)) {
       log(`Python virtual environment is unsupported after creation (${venvVersion || "unknown version"}).`);
       process.exit(1);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.25.1",
+  "version": "7.25.3",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/auto_update.py

@@ -21,7 +21,7 @@ import time
 from pathlib import Path
 
 try:
-    from product_mode import enforce_desktop_product_contract
+    from product_mode import desktop_product_requested, enforce_desktop_product_contract
 except ModuleNotFoundError as exc:
     if getattr(exc, "name", "") != "product_mode":
         raise
@@ -30,7 +30,7 @@ except ModuleNotFoundError as exc:
         core_path = str(_core_runtime)
         if core_path not in sys.path:
             sys.path.insert(0, core_path)
-    from product_mode import enforce_desktop_product_contract
+    from product_mode import desktop_product_requested, enforce_desktop_product_contract
 from runtime_home import export_resolved_nexo_home, managed_nexo_home
 
 try:
@@ -939,14 +939,94 @@ def _venv_pip_path(runtime_root: Path = NEXO_HOME) -> Path:
     return runtime_root / ".venv" / "bin" / "pip"
 
 
+def _python_version_tuple(python_bin: Path | str) -> tuple[int, int, int] | None:
+    try:
+        result = subprocess.run(
+            [str(python_bin), "-c", "import sys; print('.'.join(map(str, sys.version_info[:3])))"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except Exception:
+        return None
+    if result.returncode != 0:
+        return None
+    match = re.search(r"(\d+)\.(\d+)\.(\d+)", result.stdout or result.stderr or "")
+    if not match:
+        return None
+    return int(match.group(1)), int(match.group(2)), int(match.group(3))
+
+
+def _managed_venv_python_supported(python_bin: Path | str) -> bool:
+    version = _python_version_tuple(python_bin)
+    if not version:
+        return False
+    if desktop_product_requested():
+        return version[:2] == (3, 12)
+    return version >= (3, 10, 0)
+
+
+def _resolve_managed_venv_base_python() -> str:
+    candidates = [
+        os.environ.get("NEXO_BOOTSTRAP_PYTHON", ""),
+        os.environ.get("NEXO_RUNTIME_PYTHON", ""),
+        os.environ.get("NEXO_PYTHON", ""),
+    ]
+    if desktop_product_requested():
+        candidates.extend([
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3.12",
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3",
+            "/opt/homebrew/bin/python3.12",
+            "/usr/local/bin/python3.12",
+            shutil.which("python3.12") or "",
+        ])
+    candidates.append(sys.executable)
+    candidates.append(shutil.which("python3") or "")
+    for candidate in candidates:
+        clean = str(candidate or "").strip()
+        if clean and Path(clean).exists() and _managed_venv_python_supported(clean):
+            return clean
+    return sys.executable
+
+
+def _archive_incompatible_runtime_venv(runtime_root: Path = NEXO_HOME, reason: str = "incompatible-python") -> Path | None:
+    venv_dir = runtime_root / ".venv"
+    if not venv_dir.exists():
+        return None
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    backup_root = runtime_root / "runtime" / "backups"
+    try:
+        backup_root.mkdir(parents=True, exist_ok=True)
+        target = backup_root / f"venv-{reason}-{stamp}"
+        counter = 2
+        while target.exists():
+            target = backup_root / f"venv-{reason}-{stamp}-{counter}"
+            counter += 1
+        shutil.move(str(venv_dir), str(target))
+        _log(f"Archived incompatible managed venv at {target}")
+        return target
+    except Exception as exc:
+        _log(f"venv archive failed: {exc}")
+        return None
+
+
 def _ensure_runtime_venv(runtime_root: Path = NEXO_HOME) -> Path | None:
     venv_python = _venv_python_path(runtime_root)
     if venv_python.exists():
-        return venv_python
+        if _managed_venv_python_supported(venv_python):
+            return venv_python
+        version = _python_version_tuple(venv_python)
+        reason = f"python-{'.'.join(map(str, version[:2]))}" if version else "unreadable-python"
+        if _archive_incompatible_runtime_venv(runtime_root, reason=reason) is None:
+            return None
+    base_python = _resolve_managed_venv_base_python()
+    if not _managed_venv_python_supported(base_python):
+        _log(f"no supported base Python found for managed venv: {base_python}")
+        return None
     try:
         runtime_root.mkdir(parents=True, exist_ok=True)
         result = subprocess.run(
-            [sys.executable, "-m", "venv", str(runtime_root / ".venv")],
+            [base_python, "-m", "venv", str(runtime_root / ".venv")],
             capture_output=True,
             text=True,
             timeout=120,
@@ -965,7 +1045,7 @@ def _reinstall_pip_deps() -> bool:
     req_file = SRC_DIR / "requirements.txt"
     if not req_file.exists():
         return True
-    _ensure_runtime_venv(NEXO_HOME)
+    venv_python = _ensure_runtime_venv(NEXO_HOME)
     venv_pip = _venv_pip_path(NEXO_HOME)
     if not venv_pip.exists() and sys.platform != "win32":
         alt_pip = NEXO_HOME / ".venv" / "bin" / "pip3"
@@ -977,11 +1057,14 @@ def _reinstall_pip_deps() -> bool:
                 [str(venv_pip), "install", "--quiet", "-r", str(req_file)],
                 capture_output=True, text=True, timeout=120,
             )
-        else:
+        elif not desktop_product_requested():
             result = subprocess.run(
                 [sys.executable, "-m", "pip", "install", "--quiet", "-r", str(req_file), "--break-system-packages"],
                 capture_output=True, text=True, timeout=120,
             )
+        else:
+            _log(f"managed venv unavailable for Desktop dependency repair: {venv_python}")
+            return False
         if result.returncode != 0:
             _log(f"pip install failed (exit {result.returncode}): {result.stderr or result.stdout}")
             return False
@@ -4665,7 +4748,7 @@ def _reinstall_runtime_pip_deps(runtime_root: Path = NEXO_HOME) -> bool:
     req_file = runtime_root / "requirements.txt"
     if not req_file.exists():
         return True
-    _ensure_runtime_venv(runtime_root)
+    venv_python = _ensure_runtime_venv(runtime_root)
     venv_pip = _venv_pip_path(runtime_root)
     if not venv_pip.exists() and sys.platform != "win32":
         alt_pip = runtime_root / ".venv" / "bin" / "pip3"
@@ -4679,13 +4762,16 @@ def _reinstall_runtime_pip_deps(runtime_root: Path = NEXO_HOME) -> bool:
                 text=True,
                 timeout=120,
             )
-        else:
+        elif not desktop_product_requested():
             result = subprocess.run(
                 [sys.executable, "-m", "pip", "install", "--quiet", "-r", str(req_file), "--break-system-packages"],
                 capture_output=True,
                 text=True,
                 timeout=120,
             )
+        else:
+            _log(f"managed venv unavailable for Desktop runtime dependency repair: {venv_python}")
+            return False
         return result.returncode == 0
     except Exception:
         return False

package/src/doctor/providers/boot.py

@@ -549,6 +549,111 @@ def check_python_runtime() -> DoctorCheck:
     )
 
 
+def _desktop_product_requested() -> bool:
+    try:
+        from product_mode import desktop_product_requested
+        return bool(desktop_product_requested())
+    except Exception:
+        return str(os.environ.get("NEXO_DESKTOP_MANAGED", "")).strip() == "1"
+
+
+def _managed_venv_python_path() -> Path:
+    if sys.platform == "win32":
+        return NEXO_HOME / ".venv" / "Scripts" / "python.exe"
+    return NEXO_HOME / ".venv" / "bin" / "python3"
+
+
+def _probe_python_version(python_bin: Path | str) -> tuple[int, int, int] | None:
+    try:
+        result = subprocess.run(
+            [str(python_bin), "-c", "import sys; print('.'.join(map(str, sys.version_info[:3])))"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except Exception:
+        return None
+    if result.returncode != 0:
+        return None
+    import re
+    match = re.search(r"(\d+)\.(\d+)\.(\d+)", result.stdout or result.stderr or "")
+    if not match:
+        return None
+    return int(match.group(1)), int(match.group(2)), int(match.group(3))
+
+
+def _managed_venv_version_supported(version: tuple[int, int, int] | None) -> bool:
+    if not version:
+        return False
+    if _desktop_product_requested():
+        return version[:2] == (3, 12)
+    return version >= (3, 10, 0)
+
+
+def _repair_managed_venv_python() -> bool:
+    try:
+        import auto_update
+        return bool(auto_update._ensure_runtime_venv(NEXO_HOME)) and bool(auto_update._reinstall_pip_deps())
+    except Exception:
+        return False
+
+
+def check_managed_venv_python(fix: bool = False) -> DoctorCheck:
+    """Check the managed NEXO venv is compatible with bundled runtime deps."""
+    venv_python = _managed_venv_python_path()
+    if not venv_python.exists():
+        if not _desktop_product_requested():
+            return DoctorCheck(
+                id="boot.managed_venv_python",
+                tier="boot",
+                status="healthy",
+                severity="info",
+                summary="Managed Python venv not present yet",
+                evidence=[str(venv_python)],
+            )
+        return DoctorCheck(
+            id="boot.managed_venv_python",
+            tier="boot",
+            status="degraded",
+            severity="warn",
+            summary="Managed Python venv missing",
+            evidence=[str(venv_python)],
+            repair_plan=["Run nexo doctor --tier boot --fix or nexo update to recreate the managed venv"],
+        )
+
+    version = _probe_python_version(venv_python)
+    if _managed_venv_version_supported(version):
+        return DoctorCheck(
+            id="boot.managed_venv_python",
+            tier="boot",
+            status="healthy",
+            severity="info",
+            summary=f"Managed venv Python {'.'.join(map(str, version))}",
+            evidence=[str(venv_python)],
+        )
+
+    summary = "Managed venv Python is incompatible"
+    if version:
+        summary = f"Managed venv Python {'.'.join(map(str, version))} is incompatible"
+    if _desktop_product_requested():
+        summary += " — Desktop bundled wheels require Python 3.12"
+    if fix and _repair_managed_venv_python():
+        post = check_managed_venv_python(fix=False)
+        if post.status == "healthy":
+            post.fixed = True
+            post.summary += " (fixed)"
+            return post
+    return DoctorCheck(
+        id="boot.managed_venv_python",
+        tier="boot",
+        status="degraded",
+        severity="warn",
+        summary=summary,
+        evidence=[str(venv_python)],
+        repair_plan=["Run nexo doctor --tier boot --fix or nexo update to archive and recreate the managed venv"],
+    )
+
+
 CRITICAL_CONFIG_FILES = (
     ("schedule.json", ("config", "schedule.json")),
     ("optionals.json", ("config", "optionals.json")),
@@ -803,6 +908,7 @@ def run_boot_checks(fix: bool = False) -> list[DoctorCheck]:
         safe_check(check_disk_space),
         safe_check(check_wrapper_scripts),
         safe_check(check_python_runtime),
+        safe_check(check_managed_venv_python, fix=fix),
         safe_check(check_config_parse),
         safe_check(check_core_dev_packaged_install),
         safe_check(check_dashboard_desktop_contract),

package/src/plugins/update.py

@@ -12,6 +12,12 @@ import time
 from pathlib import Path
 
 from runtime_home import export_resolved_nexo_home
+try:
+    from product_mode import desktop_product_requested
+except Exception:  # pragma: no cover - stale packaged runtimes may miss product_mode during update
+    def desktop_product_requested() -> bool:
+        return str(os.environ.get("NEXO_DESKTOP_MANAGED", "")).strip() == "1"
+
 from runtime_versioning import (
     activate_versioned_runtime_snapshot,
     compute_mcp_runtime_fingerprint,
@@ -239,15 +245,94 @@ def _venv_pip_path(runtime_root: Path | None = None) -> Path:
     return root / ".venv" / "bin" / "pip"
 
 
+def _python_version_tuple(python_bin: Path | str) -> tuple[int, int, int] | None:
+    try:
+        result = subprocess.run(
+            [str(python_bin), "-c", "import sys; print('.'.join(map(str, sys.version_info[:3])))"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except Exception:
+        return None
+    if result.returncode != 0:
+        return None
+    match = re.search(r"(\d+)\.(\d+)\.(\d+)", result.stdout or result.stderr or "")
+    if not match:
+        return None
+    return int(match.group(1)), int(match.group(2)), int(match.group(3))
+
+
+def _managed_venv_python_supported(python_bin: Path | str) -> bool:
+    version = _python_version_tuple(python_bin)
+    if not version:
+        return False
+    if desktop_product_requested():
+        return version[:2] == (3, 12)
+    return version >= (3, 10, 0)
+
+
+def _resolve_managed_venv_base_python() -> str:
+    candidates = [
+        os.environ.get("NEXO_BOOTSTRAP_PYTHON", ""),
+        os.environ.get("NEXO_RUNTIME_PYTHON", ""),
+        os.environ.get("NEXO_PYTHON", ""),
+    ]
+    if desktop_product_requested():
+        candidates.extend([
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3.12",
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3",
+            "/opt/homebrew/bin/python3.12",
+            "/usr/local/bin/python3.12",
+            shutil.which("python3.12") or "",
+        ])
+    candidates.extend([sys.executable, shutil.which("python3") or ""])
+    for candidate in candidates:
+        clean = str(candidate or "").strip()
+        if clean and Path(clean).exists() and _managed_venv_python_supported(clean):
+            return clean
+    return sys.executable
+
+
+def _archive_incompatible_managed_venv(root: Path, reason: str = "incompatible-python") -> Path | None:
+    venv_dir = root / ".venv"
+    if not venv_dir.exists():
+        return None
+    backup_root = root / "runtime" / "backups"
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    try:
+        backup_root.mkdir(parents=True, exist_ok=True)
+        target = backup_root / f"venv-{reason}-{stamp}"
+        counter = 2
+        while target.exists():
+            target = backup_root / f"venv-{reason}-{stamp}-{counter}"
+            counter += 1
+        shutil.move(str(venv_dir), str(target))
+        return target
+    except Exception:
+        return None
+
+
 def _ensure_managed_venv(runtime_root: Path | None = None) -> str | None:
     root = runtime_root or _nexo_home()
     venv_python = _venv_python_path(root)
+    if venv_python.exists():
+        if _managed_venv_python_supported(venv_python):
+            return None
+        version = _python_version_tuple(venv_python)
+        reason = f"python-{'.'.join(map(str, version[:2]))}" if version else "unreadable-python"
+        archived = _archive_incompatible_managed_venv(root, reason=reason)
+        if archived is None:
+            return "managed venv uses an incompatible Python and could not be archived"
+    base_python = _resolve_managed_venv_base_python()
+    if not _managed_venv_python_supported(base_python):
+        return f"no supported Python found for managed venv: {base_python}"
     if venv_python.exists():
         return None
     try:
         root.mkdir(parents=True, exist_ok=True)
         result = subprocess.run(
-            [sys.executable, "-m", "venv", str(root / ".venv")],
+            [base_python, "-m", "venv", str(root / ".venv")],
             capture_output=True,
             text=True,
             timeout=120,
@@ -280,18 +365,41 @@ def _npm_command_parts() -> tuple[list[str], dict[str, str]]:
     desktop_node = str(os.environ.get("NEXO_DESKTOP_NODE", "")).strip()
     bundled_npm_cli = str(os.environ.get("NEXO_DESKTOP_NPM_CLI", "")).strip()
     env = dict(os.environ)
-    if desktop_node and bundled_npm_cli and Path(desktop_node).exists():
+    if desktop_node and bundled_npm_cli and Path(desktop_node).exists() and Path(bundled_npm_cli).exists():
         env["ELECTRON_RUN_AS_NODE"] = "1"
+        _apply_desktop_npm_prefix(env)
         return [desktop_node, bundled_npm_cli], env
     return ["npm"], env
 
 
+def _desktop_npm_prefix() -> str:
+    return (
+        str(os.environ.get("NEXO_DESKTOP_NPM_PREFIX", "")).strip()
+        or str(os.environ.get("NEXO_CLAUDE_PREFIX", "")).strip()
+        or str(NEXO_HOME / "runtime" / "bootstrap" / "npm-global")
+    )
+
+
+def _apply_desktop_npm_prefix(env: dict[str, str]) -> None:
+    if env.get("ELECTRON_RUN_AS_NODE") != "1":
+        return
+    npm_prefix = _desktop_npm_prefix()
+    if not npm_prefix:
+        return
+    env.setdefault("NPM_CONFIG_PREFIX", npm_prefix)
+    prefix_bin = str(Path(npm_prefix) / "bin")
+    current_path = str(env.get("PATH", ""))
+    entries = [entry for entry in current_path.split(os.pathsep) if entry]
+    env["PATH"] = os.pathsep.join([prefix_bin, *[entry for entry in entries if entry != prefix_bin]])
+
+
 def _run_npm(args: list[str], **kwargs):
     cmd, env = _npm_command_parts()
     extra_env = kwargs.pop("env", None)
     merged_env = dict(env)
     if extra_env:
         merged_env.update(extra_env)
+    _apply_desktop_npm_prefix(merged_env)
     return subprocess.run([*cmd, *args], env=merged_env, **kwargs)
 
 
@@ -653,6 +761,8 @@ def _reinstall_pip_deps() -> str | None:
         if alt_pip.exists():
             venv_pip = alt_pip
     if not venv_pip.exists():
+        if desktop_product_requested():
+            return "managed Desktop venv pip is unavailable after repair"
         # No venv, try system pip with --break-system-packages
         try:
             result = subprocess.run(
@@ -1268,7 +1378,7 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
     try:
         _emit_progress(progress_fn, "Downloading and applying the latest npm package...")
         result = _run_npm(
-            ["update", "-g", "nexo-brain"],
+            ["install", "-g", "nexo-brain@latest"],
             capture_output=True, text=True, timeout=120,
             env={**os.environ, "NEXO_HOME": str(NEXO_HOME)},
         )