nexo-brain 7.13.7 → 7.13.9

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.13.7",
+  "version": "7.13.9",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,11 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.13.7` is the current packaged-runtime line. Patch release over v7.13.6 — Brain adds an authenticated official protocol-card client (`nexo_card_catalog`, `nexo_card_get`, `nexo_card_match`) so agents can ask the NEXO Desktop backend for the right task protocol at runtime. The protocol corpus stays private on the server; this open-source package ships only the client, tool map, and agent guidance.
+Version `7.13.9` is the current packaged-runtime line. Patch release over v7.13.8 — Brain now moves aside an existing managed `.venv` when it was created with unsupported Python <3.10, then recreates it with the supported interpreter prepared by Desktop.
+
+Previously in `7.13.8`: patch release — Brain rejects Python <3.10 during Desktop-managed fresh installs, honors the Python interpreter prepared by Desktop, and fails clearly before dependency resolution if an unsupported Apple Python 3.9 reaches the installer.
+
+Previously in `7.13.7`: patch release — Brain adds an authenticated official protocol-card client (`nexo_card_catalog`, `nexo_card_get`, `nexo_card_match`) so agents can ask the NEXO Desktop backend for the right task protocol at runtime. The protocol corpus stays private on the server; this open-source package ships only the client, tool map, and agent guidance.
 
 Previously in `7.13.6`: patch release — Codex hook sync now renders the managed `PreToolUse` shell/exec_command guard with native Windows `cmd.exe` syntax while preserving the existing POSIX command on macOS/Linux. Result: coordinated Desktop bundles can ship the fixed Brain without changing the Mac/Windows installation contract.
 

package/bin/nexo-brain.js

@@ -36,6 +36,8 @@ if (process.platform === "win32") {
 let NEXO_HOME = process.env.NEXO_HOME || path.join(require("os").homedir(), ".nexo");
 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;
 
 function normalizeAssistantNameCandidate(value) {
   return String(value || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
@@ -225,6 +227,57 @@ function run(cmd, opts = {}) {
   }
 }
 
+function shSingleQuote(value) {
+  return "'" + String(value || "").replace(/'/g, "'\\''") + "'";
+}
+
+function runPythonProbe(pythonBin, args, timeout = 15000) {
+  if (!pythonBin) return null;
+  try {
+    const result = spawnSync(pythonBin, args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout,
+    });
+    if (result.status !== 0) return null;
+    return String(result.stdout || result.stderr || "").trim();
+  } catch {
+    return null;
+  }
+}
+
+function pythonVersion(pythonBin) {
+  return runPythonProbe(pythonBin, ["-c", "import sys; print(sys.version.split()[0])"]);
+}
+
+function pythonVersionMeetsMinimum(versionText) {
+  const match = String(versionText || "").trim().match(/^(\d+)\.(\d+)(?:\.|$)/);
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > MIN_INSTALLER_PYTHON_MAJOR
+    || (major === MIN_INSTALLER_PYTHON_MAJOR && minor >= MIN_INSTALLER_PYTHON_MINOR);
+}
+
+function resolveInstallerPython() {
+  const candidates = [
+    process.env.NEXO_BOOTSTRAP_PYTHON,
+    process.env.NEXO_RUNTIME_PYTHON,
+    process.env.NEXO_PYTHON,
+    run("which python3"),
+    run("which python"),
+  ].filter(Boolean);
+  const seen = new Set();
+  for (const candidate of candidates) {
+    const clean = String(candidate || "").trim();
+    if (!clean || seen.has(clean)) continue;
+    seen.add(clean);
+    const version = pythonVersion(clean);
+    if (version && pythonVersionMeetsMinimum(version)) return clean;
+  }
+  return "";
+}
+
 function findBundledWheel(wheelsDir, prefix) {
   try {
     const normalizedPrefix = String(prefix || "").toLowerCase() + "-";
@@ -250,6 +303,46 @@ function pythonHasPip(pythonBin) {
   }
 }
 
+function managedVenvPythonPath(nexoHome = NEXO_HOME) {
+  const venvPath = path.join(nexoHome, ".venv");
+  return process.platform === "win32"
+    ? path.join(venvPath, "Scripts", "python.exe")
+    : path.join(venvPath, "bin", "python3");
+}
+
+function safeTimestampForPath() {
+  return new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+}
+
+function uniqueBackupPath(targetPath, suffix) {
+  const dir = path.dirname(targetPath);
+  const base = path.basename(targetPath);
+  const stamp = safeTimestampForPath();
+  let candidate = path.join(dir, `${base}.${suffix}-${stamp}`);
+  if (!fs.existsSync(candidate)) return candidate;
+  for (let i = 2; i < 100; i += 1) {
+    candidate = path.join(dir, `${base}.${suffix}-${stamp}-${i}`);
+    if (!fs.existsSync(candidate)) return candidate;
+  }
+  return path.join(dir, `${base}.${suffix}-${stamp}-${process.pid}`);
+}
+
+function ensureManagedVenvCompatible(venvPath, venvPython) {
+  if (!fs.existsSync(venvPython)) return;
+  const version = pythonVersion(venvPython);
+  if (version && pythonVersionMeetsMinimum(version)) return;
+
+  const reason = version ? `Python ${version}` : "an unreadable Python executable";
+  const backupPath = uniqueBackupPath(venvPath, "unsupported-python");
+  log(`  Existing Python virtual environment uses ${reason}; moving it aside to recreate.`);
+  try {
+    fs.renameSync(venvPath, backupPath);
+  } catch (err) {
+    throw new Error(`Existing NEXO Python virtual environment is incompatible and could not be moved aside: ${err.message || err}`);
+  }
+  log(`  Previous Python virtual environment moved to ${backupPath}`);
+}
+
 function seedPipFromBundledWheels(venvPython, bundledWheelsDir) {
   if (!fs.existsSync(venvPython) || !fs.existsSync(bundledWheelsDir)) return false;
   if (pythonHasPip(venvPython)) return true;
@@ -523,15 +616,13 @@ function resolveSystemPython() {
 }
 
 function ensureWarmupPython(nexoHome = NEXO_HOME) {
-  const existing = findVenvPython(nexoHome);
-  if (existing) return existing;
-
-  const basePython = resolveSystemPython();
   const venvPath = path.join(nexoHome, ".venv");
-  const venvPython = process.platform === "win32"
-    ? path.join(venvPath, "Scripts", "python.exe")
-    : path.join(venvPath, "bin", "python3");
+  const venvPython = managedVenvPythonPath(nexoHome);
   fs.mkdirSync(nexoHome, { recursive: true });
+  ensureManagedVenvCompatible(venvPath, venvPython);
+  if (fs.existsSync(venvPython)) return venvPython;
+
+  const basePython = resolveInstallerPython() || resolveSystemPython();
   if (!fs.existsSync(venvPython)) {
     log("  Creating Python virtual environment for model warmup...");
     const result = spawnSync(basePython, ["-m", "venv", venvPath], { stdio: "inherit", timeout: 120000 });
@@ -1710,6 +1801,48 @@ function buildManagedCliEnv(extraEnv = {}) {
   };
 }
 
+function ensureDesktopNodeShim(desktopNode) {
+  const clean = String(desktopNode || "").trim();
+  if (!clean) return "";
+  const shimDir = path.join(NEXO_HOME, "runtime", "bootstrap", "node-shim");
+  fs.mkdirSync(shimDir, { recursive: true });
+  if (process.platform === "win32") {
+    const shimPath = path.join(shimDir, "node.cmd");
+    fs.writeFileSync(
+      shimPath,
+      `@echo off\r\nset ELECTRON_RUN_AS_NODE=1\r\n"${clean}" %*\r\n`,
+    );
+    return shimDir;
+  }
+  const shimPath = path.join(shimDir, "node");
+  fs.writeFileSync(
+    shimPath,
+    [
+      "#!/bin/sh",
+      "export ELECTRON_RUN_AS_NODE=1",
+      `exec ${shSingleQuote(clean)} "$@"`,
+      "",
+    ].join("\n"),
+  );
+  fs.chmodSync(shimPath, 0o755);
+  return shimDir;
+}
+
+function withDesktopNodeShim(env, desktopNode) {
+  try {
+    const shimDir = ensureDesktopNodeShim(desktopNode);
+    if (!shimDir) return env;
+    return {
+      ...env,
+      ELECTRON_RUN_AS_NODE: "1",
+      PATH: [shimDir, env.PATH || ""].filter(Boolean).join(path.delimiter),
+    };
+  } catch (err) {
+    log(`Desktop Node shim could not be created: ${String(err && err.message || err)}`);
+    return env;
+  }
+}
+
 function resolveManagedClaudeBinary() {
   const prefix = managedClaudePrefix();
   const candidates = process.platform === "win32"
@@ -1921,11 +2054,13 @@ function installClaudeCodeCli(platform) {
     return { installed: true, path: claudeInstalled };
   }
 
-  const installEnv = buildManagedCliEnv();
   const desktopNode = String(process.env.NEXO_DESKTOP_NODE || "").trim();
   const bundledNpmCli = String(process.env.NEXO_DESKTOP_NPM_CLI || "").trim();
   const managedPrefix = managedClaudePrefix();
   const desktopManaged = isDesktopManagedInstall();
+  const npmViaDesktop = desktopNode && bundledNpmCli;
+  let installEnv = buildManagedCliEnv();
+  if (desktopNode) installEnv = withDesktopNodeShim(installEnv, desktopNode);
 
   // OFFLINE-FIRST v0.32.4: install claude-code wrapper + ALL its native packs
   // from bundled tarballs. Path: resources/brain-bundle/claude-code/*.tgz.
@@ -1963,8 +2098,18 @@ function installClaudeCodeCli(platform) {
       const tgzPaths = [path.join(bundledClaudeDir, wrapper), ...nativePacks.map((p) => path.join(bundledClaudeDir, p))];
       log("  Installing claude-code from bundled tarballs (offline, " + (1 + nativePacks.length) + " packs)...");
       spawnSync(
-        "npm",
-        ["install", "-g", "--prefix", managedPrefix, "--offline", "--no-audit", "--no-fund", ...tgzPaths],
+        npmViaDesktop ? desktopNode : "npm",
+        [
+          ...(npmViaDesktop ? [bundledNpmCli] : []),
+          "install",
+          "-g",
+          "--prefix",
+          managedPrefix,
+          "--offline",
+          "--no-audit",
+          "--no-fund",
+          ...tgzPaths,
+        ],
         { stdio: "inherit", env: installEnv },
       );
       claudeInstalled = detectInstalledClients().claude_code.path || "";
@@ -1977,8 +2122,15 @@ function installClaudeCodeCli(platform) {
       const tgzPath = path.join(bundledClaudeDir, wrapper);
       log("  Installing claude-code from bundled wrapper only (legacy bundle, may need network for native pack)...");
       spawnSync(
-        "npm",
-        ["install", "-g", "--prefix", managedPrefix, tgzPath],
+        npmViaDesktop ? desktopNode : "npm",
+        [
+          ...(npmViaDesktop ? [bundledNpmCli] : []),
+          "install",
+          "-g",
+          "--prefix",
+          managedPrefix,
+          tgzPath,
+        ],
         { stdio: "inherit", env: installEnv },
       );
       claudeInstalled = detectInstalledClients().claude_code.path || "";
@@ -2284,7 +2436,7 @@ async function maybeConfigurePublicContribution(schedule, useDefaults) {
  * Resolve the venv python path for an existing NEXO_HOME installation.
  */
 function findVenvPython(nexoHome) {
-  const venvPy = path.join(nexoHome, ".venv", "bin", "python3");
+  const venvPy = managedVenvPythonPath(nexoHome);
   if (fs.existsSync(venvPy)) return venvPy;
   return null;
 }
@@ -3081,7 +3233,7 @@ async function runSetup() {
   }
 
   // Find or install Python (platform-aware)
-  let python = run("which python3");
+  let python = resolveInstallerPython();
   if (!python) {
     if (platform === "darwin") {
       // v0.32.5 — Mac vanilla NO trae python3. La auto-instalación de
@@ -3122,7 +3274,7 @@ async function runSetup() {
         // fallan al import. Pinning a `python@3.12` evita el drift.
         log("Python 3.12 not found. Installing via Homebrew...");
         spawnSync("brew", ["install", "python@3.12"], { stdio: "inherit" });
-        python = run("which python3.12") || run("which python3");
+        python = resolveInstallerPython() || run("which python3.12") || run("which python3");
       }
     } else if (platform === "linux") {
       // Linux: try apt or yum
@@ -3132,7 +3284,7 @@ async function runSetup() {
       } else if (run("which yum")) {
         spawnSync("sudo", ["yum", "install", "-y", "python3", "python3-pip"], { stdio: "inherit" });
       }
-      python = run("which python3");
+      python = resolveInstallerPython();
     }
     if (!python) {
       log("Python 3 not found and couldn't install automatically.");
@@ -3140,7 +3292,13 @@ async function runSetup() {
       process.exit(1);
     }
   }
-  const pyVersion = run(`${python} --version`);
+  const pyVersion = pythonVersion(python);
+  if (!pyVersion || !pythonVersionMeetsMinimum(pyVersion)) {
+    log(pyVersion
+      ? `Python at ${python} is ${pyVersion}; NEXO Brain requires Python >=${MIN_INSTALLER_PYTHON_MAJOR}.${MIN_INSTALLER_PYTHON_MINOR}.`
+      : `Python at ${python || "(not found)"} is not executable.`);
+    process.exit(1);
+  }
   log(`Found ${pyVersion} at ${python}`);
   logMacPermissionsNotice(NEXO_HOME, python);
 
@@ -3582,11 +3740,11 @@ async function runSetup() {
   log("Installing cognitive engine dependencies...");
   fs.mkdirSync(NEXO_HOME, { recursive: true });
   const venvPath = path.join(NEXO_HOME, ".venv");
-  const venvPython = platform === "win32"
-    ? path.join(venvPath, "Scripts", "python.exe")
-    : path.join(venvPath, "bin", "python3");
+  const venvPython = managedVenvPythonPath(NEXO_HOME);
   const bundledWheelsDir = path.join(__dirname, "..", "python-wheels");
 
+  ensureManagedVenvCompatible(venvPath, venvPython);
+
   // Create venv if it doesn't exist
   if (!fs.existsSync(venvPython)) {
     log("  Creating Python virtual environment...");
@@ -3604,6 +3762,13 @@ async function runSetup() {
       }
     }
   }
+  if (fs.existsSync(venvPython)) {
+    const venvVersion = pythonVersion(venvPython);
+    if (!venvVersion || !pythonVersionMeetsMinimum(venvVersion)) {
+      log(`Python virtual environment is unsupported after creation (${venvVersion || "unknown version"}).`);
+      process.exit(1);
+    }
+  }
   if (fs.existsSync(venvPython) && !pythonHasPip(venvPython)) {
     seedPipFromBundledWheels(venvPython, bundledWheelsDir);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.13.7",
+  "version": "7.13.9",
   "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",