nexo-brain 7.25.6 → 7.26.0

package/src/client_sync.py

@@ -10,6 +10,7 @@ import shlex
 import shutil
 import subprocess
 import sys
+import tarfile
 from pathlib import Path
 
 from calibration_runtime import load_runtime_calibration
@@ -80,6 +81,7 @@ except Exception:
 
 
 CLAUDE_CODE_NPM_PACKAGE = "@anthropic-ai/claude-code"
+CODEX_NPM_PACKAGE = "@openai/codex"
 DEFAULT_ASSISTANT_NAME = "Nova"
 HOOK_TIMEOUTS_BY_EVENT = {
     "SessionStart": 40,
@@ -235,6 +237,159 @@ def _managed_claude_prefix(user_home: Path | None = None) -> Path:
     return home / ".nexo" / "runtime" / "bootstrap" / "npm-global"
 
 
+def _brain_bundle_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _platform_slug() -> str:
+    if sys.platform.startswith("darwin"):
+        os_part = "darwin"
+    elif sys.platform.startswith("linux"):
+        os_part = "linux"
+    elif sys.platform.startswith("win"):
+        os_part = "win32"
+    else:
+        os_part = sys.platform
+    machine = __import__("platform").machine().lower()
+    if machine in {"x86_64", "amd64"}:
+        arch = "x64"
+    elif machine in {"aarch64", "arm64"}:
+        arch = "arm64"
+    else:
+        arch = machine
+    return f"{os_part}-{arch}"
+
+
+def _install_npm_package_from_bundle(
+    *,
+    bundle_dir: Path,
+    wrapper_pattern: str,
+    package_name: str,
+    managed_prefix: Path,
+    env: dict[str, str],
+    attempts: list[str],
+) -> bool:
+    if not bundle_dir.is_dir():
+        return False
+    all_tgz = sorted(item for item in bundle_dir.iterdir() if item.name.endswith(".tgz"))
+    wrapper_re = re.compile(wrapper_pattern)
+    wrapper = next((item for item in all_tgz if wrapper_re.match(item.name)), None)
+    if not wrapper:
+        return False
+    slug = _platform_slug()
+    native_packs = [
+        item
+        for item in all_tgz
+        if item != wrapper and (f"-{slug}.tgz" in item.name or f"-{slug}-" in item.name)
+    ]
+    tgz_paths = [wrapper, *native_packs] if native_packs else [wrapper]
+    desktop_node, bundled_npm_cli = _bundled_npm_runtime()
+    if desktop_node and bundled_npm_cli:
+        cmd = [
+            desktop_node,
+            bundled_npm_cli,
+            "install",
+            "-g",
+            "--prefix",
+            str(managed_prefix),
+            "--offline",
+            "--no-audit",
+            "--no-fund",
+            *(str(item) for item in tgz_paths),
+        ]
+        run_env = {**env, "ELECTRON_RUN_AS_NODE": "1"}
+    else:
+        cmd = [
+            "npm",
+            "install",
+            "-g",
+            "--prefix",
+            str(managed_prefix),
+            "--offline",
+            "--no-audit",
+            "--no-fund",
+            *(str(item) for item in tgz_paths),
+        ]
+        run_env = env
+    try:
+        install = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=300,
+            env=run_env,
+        )
+        if install.returncode == 0:
+            return True
+        attempts.append((install.stderr or install.stdout or f"{package_name} bundled install failed").strip())
+    except Exception as exc:
+        attempts.append(f"{package_name} bundled install failed: {exc}")
+    return False
+
+
+def _install_codex_vendor_from_bundle(*, bundle_dir: Path, managed_prefix: Path, attempts: list[str]) -> bool:
+    package_roots = [
+        managed_prefix / "lib" / "node_modules" / "@openai" / "codex",
+        managed_prefix / "node_modules" / "@openai" / "codex",
+    ]
+    package_root = next((item for item in package_roots if item.exists()), package_roots[0])
+    if not package_root.exists() or not bundle_dir.is_dir():
+        return False
+    slug = _platform_slug()
+    native_packs = sorted(
+        item for item in bundle_dir.iterdir()
+        if item.name.endswith(".tgz") and (f"-{slug}.tgz" in item.name or f"-{slug}-" in item.name)
+    )
+    if not native_packs:
+        attempts.append(f"no bundled Codex native vendor found for {slug}")
+        return False
+    vendor_dest = package_root / "vendor"
+    vendor_dest.mkdir(parents=True, exist_ok=True)
+    for pack in native_packs:
+        try:
+            with tarfile.open(pack, "r:gz") as archive:
+                members = [member for member in archive.getmembers() if member.name.startswith("package/vendor/")]
+                for member in members:
+                    relative = Path(member.name).relative_to("package/vendor")
+                    target = vendor_dest / relative
+                    if member.isdir():
+                        target.mkdir(parents=True, exist_ok=True)
+                        continue
+                    if not member.isfile():
+                        continue
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    source = archive.extractfile(member)
+                    if source is None:
+                        continue
+                    with source, target.open("wb") as out:
+                        shutil.copyfileobj(source, out)
+                    try:
+                        target.chmod(member.mode)
+                    except Exception:
+                        pass
+            return True
+        except Exception as exc:
+            attempts.append(f"Codex native vendor extract failed for {pack.name}: {exc}")
+    return False
+
+
+def _codex_vendor_present(managed_prefix: Path) -> bool:
+    package_roots = [
+        managed_prefix / "lib" / "node_modules" / "@openai" / "codex",
+        managed_prefix / "node_modules" / "@openai" / "codex",
+    ]
+    for package_root in package_roots:
+        vendor_root = package_root / "vendor"
+        if not vendor_root.exists():
+            continue
+        try:
+            if any(candidate.is_file() for candidate in vendor_root.rglob("bin/codex*")):
+                return True
+        except Exception:
+            continue
+    return False
+
+
 def _desktop_product_requested(user_home: Path | None = None) -> bool:
     if str(os.environ.get("NEXO_DESKTOP_MANAGED", "")).strip() == "1":
         return True
@@ -289,6 +444,13 @@ def _installed_client_path(client_key: str, *, user_home: Path | None = None) ->
     return ""
 
 
+def _sync_codex_binary(home_path: Path) -> str:
+    if _desktop_product_requested(home_path):
+        info = detect_installed_clients(user_home=home_path).get("codex", {})
+        return str(info.get("path") or "") if info.get("installed") else ""
+    return shutil.which("codex") or ""
+
+
 def ensure_claude_code_installed(*, user_home: str | os.PathLike[str] | None = None) -> dict:
     home_path = Path(user_home).expanduser() if user_home else _user_home()
     desktop_managed = _desktop_product_requested(home_path)
@@ -471,6 +633,167 @@ def ensure_claude_code_installed(*, user_home: str | os.PathLike[str] | None = N
     }
 
 
+def ensure_codex_installed(*, user_home: str | os.PathLike[str] | None = None) -> dict:
+    home_path = Path(user_home).expanduser() if user_home else _user_home()
+    desktop_managed = _desktop_product_requested(home_path)
+    managed_prefix = _managed_claude_prefix(home_path)
+    existing = _installed_client_path("codex", user_home=home_path)
+    if existing and (not desktop_managed or _codex_vendor_present(managed_prefix)):
+        return {
+            "ok": True,
+            "client": "codex",
+            "installed": True,
+            "changed": False,
+            "action": "already_installed_managed" if desktop_managed else "already_installed",
+            "path": existing,
+            "attempts": [],
+        }
+
+    attempts: list[str] = []
+    if existing and desktop_managed:
+        attempts.append("managed Codex wrapper exists but native vendor is missing; repairing bundled vendor")
+    env = _cli_install_env(home_path)
+    env.setdefault("npm_config_prefix", str(managed_prefix))
+    env["PATH"] = os.pathsep.join(
+        [str(managed_prefix / "bin"), *(item for item in str(env.get("PATH", "")).split(os.pathsep) if item)]
+    )
+
+    desktop_node, bundled_npm_cli = _bundled_npm_runtime()
+    bundle_dir = _brain_bundle_root() / "codex"
+    if desktop_managed and not (desktop_node and bundled_npm_cli):
+        vendor_installed = _install_codex_vendor_from_bundle(
+            bundle_dir=bundle_dir,
+            managed_prefix=managed_prefix,
+            attempts=attempts,
+        )
+        installed_after_vendor = _installed_client_path("codex", user_home=home_path)
+        if installed_after_vendor and vendor_installed:
+            return {
+                "ok": True,
+                "client": "codex",
+                "installed": True,
+                "changed": True,
+                "action": "installed_bundled_vendor",
+                "path": installed_after_vendor,
+                "attempts": attempts,
+            }
+        return {
+            "ok": False,
+            "client": "codex",
+            "installed": False,
+            "changed": False,
+            "action": "failed",
+            "path": "",
+            "attempts": attempts,
+            "error": (
+                "Desktop-managed Codex install requires the NEXO Desktop bundled Codex runtime; "
+                "global `npm -g` fallbacks are disabled."
+            ),
+        }
+
+    wrapper_installed = _install_npm_package_from_bundle(
+        bundle_dir=bundle_dir,
+        wrapper_pattern=r"^openai-codex-\d+\.\d+\.\d+\.tgz$",
+        package_name=CODEX_NPM_PACKAGE,
+        managed_prefix=managed_prefix,
+        env=env,
+        attempts=attempts,
+    )
+    vendor_installed = _install_codex_vendor_from_bundle(bundle_dir=bundle_dir, managed_prefix=managed_prefix, attempts=attempts)
+    installed_after_bundle = _installed_client_path("codex", user_home=home_path)
+    if installed_after_bundle and vendor_installed:
+        return {
+            "ok": True,
+            "client": "codex",
+            "installed": True,
+            "changed": True,
+            "action": "installed_via_bundled_tarballs",
+            "path": installed_after_bundle,
+            "attempts": attempts,
+        }
+    if wrapper_installed and not vendor_installed:
+        attempts.append("bundled Codex wrapper installed but native vendor extraction failed; falling back to online install")
+
+    if desktop_node and bundled_npm_cli:
+        try:
+            install = subprocess.run(
+                [
+                    desktop_node,
+                    bundled_npm_cli,
+                    "install",
+                    "-g",
+                    "--prefix",
+                    str(managed_prefix),
+                    CODEX_NPM_PACKAGE,
+                ],
+                capture_output=True,
+                text=True,
+                timeout=300,
+                env={**env, "ELECTRON_RUN_AS_NODE": "1"},
+            )
+            if install.returncode != 0:
+                attempts.append((install.stderr or install.stdout or "bundled npm install failed").strip())
+        except Exception as exc:
+            attempts.append(f"bundled npm install failed: {exc}")
+        installed_after_npm = _installed_client_path("codex", user_home=home_path)
+        if installed_after_npm and (not desktop_managed or _codex_vendor_present(managed_prefix)):
+            return {
+                "ok": True,
+                "client": "codex",
+                "installed": True,
+                "changed": True,
+                "action": "installed_via_bundled_npm",
+                "path": installed_after_npm,
+                "attempts": attempts,
+            }
+        if installed_after_npm and desktop_managed:
+            attempts.append("managed Codex wrapper installed but native vendor is missing after bundled npm install")
+
+    if desktop_managed:
+        error = (
+            "Desktop-managed Codex install did not produce the managed "
+            "`~/.nexo/runtime/bootstrap/npm-global/bin/codex` binary."
+        )
+        return {
+            "ok": False,
+            "client": "codex",
+            "installed": False,
+            "changed": False,
+            "action": "failed",
+            "path": "",
+            "attempts": attempts,
+            "error": error,
+        }
+
+    install_error = ""
+    try:
+        install = subprocess.run(
+            ["npm", "install", "-g", "--prefix", str(managed_prefix), CODEX_NPM_PACKAGE],
+            capture_output=True,
+            text=True,
+            timeout=180,
+            env=env,
+        )
+        if install.returncode != 0:
+            install_error = (install.stderr or install.stdout or "npm install failed").strip()
+            attempts.append(install_error)
+    except Exception as exc:
+        install_error = f"npm install failed: {exc}"
+        attempts.append(install_error)
+
+    installed_path = _installed_client_path("codex", user_home=home_path)
+    return {
+        "ok": bool(installed_path),
+        "client": "codex",
+        "installed": bool(installed_path),
+        "changed": bool(installed_path),
+        "action": "installed" if installed_path else "failed",
+        "path": installed_path or "",
+        "attempts": attempts,
+        **({} if installed_path else {"error": install_error or "Codex install did not produce a `codex` binary in PATH"}),
+    }
+
+
 def build_server_config(
     *,
     nexo_home: str | os.PathLike[str] | None = None,
@@ -1334,7 +1657,7 @@ def sync_codex(
         operator_name=operator_name,
         client="codex",
     )
-    codex_bin = shutil.which("codex")
+    codex_bin = _sync_codex_binary(home_path)
     config_path = _codex_config_path(home_path)
     hooks_path = _codex_hooks_path(home_path)
     if not codex_bin:
@@ -1423,6 +1746,7 @@ def sync_all_clients(
     enabled_clients: list[str] | tuple[str, ...] | set[str] | None = None,
     preferences: dict | None = None,
     auto_install_missing_claude: bool = False,
+    auto_install_missing_codex: bool = False,
 ) -> dict:
     nexo_home_path = Path(nexo_home).expanduser() if nexo_home else _default_nexo_home()
     guardian_runtime_surfaces_result: dict = {
@@ -1469,6 +1793,8 @@ def sync_all_clients(
     install_results: dict[str, dict] = {}
     if auto_install_missing_claude and "claude_code" in enabled_set:
         install_results["claude_code"] = ensure_claude_code_installed(user_home=user_home)
+    if auto_install_missing_codex and "codex" in enabled_set:
+        install_results["codex"] = ensure_codex_installed(user_home=user_home)
 
     def _safe(label: str, fn) -> dict:
         if label not in enabled_set:

package/src/db/_schema.py

@@ -1117,6 +1117,28 @@ def _m41_automation_sessions_columns(conn):
     )
 
 
+def _m69_provider_runtime_metadata(conn):
+    """Add provider/runtime metadata required for Anthropic/OpenAI parity."""
+    if not _table_exists(conn, "automation_runs"):
+        _m28_automation_runs(conn)
+    if not _table_exists(conn, "cron_runs"):
+        _m17_cron_runs(conn)
+
+    if _table_exists(conn, "automation_runs"):
+        _migrate_add_column(conn, "automation_runs", "provider", "TEXT DEFAULT ''")
+        _migrate_add_column(conn, "automation_runs", "runtime_version", "TEXT DEFAULT ''")
+        _migrate_add_column(conn, "automation_runs", "runtime_session_id", "TEXT DEFAULT ''")
+        _migrate_add_index(conn, "idx_automation_runs_provider", "automation_runs", "provider")
+    if _table_exists(conn, "cron_runs"):
+        _migrate_add_column(conn, "cron_runs", "provider", "TEXT DEFAULT ''")
+        _migrate_add_column(conn, "cron_runs", "backend", "TEXT DEFAULT ''")
+        _migrate_add_column(conn, "cron_runs", "runtime_snapshot", "TEXT DEFAULT '{}'")
+        _migrate_add_index(conn, "idx_cron_runs_provider", "cron_runs", "provider")
+    if _table_exists(conn, "sessions"):
+        _migrate_add_column(conn, "sessions", "session_provider", "TEXT DEFAULT ''")
+        _migrate_add_index(conn, "idx_sessions_provider", "sessions", "session_provider")
+
+
 def _m42_v6_0_1_hotfix(conn):
     """v6.0.1 hotfix — last_heartbeat_ts on sessions + hook_inbox_reminders.
 
@@ -2247,6 +2269,7 @@ MIGRATIONS = [
     (66, "transcript_index", _m66_transcript_index),
     (67, "diary_quality_backfill_repair", _m67_diary_quality_backfill_repair),
     (68, "memory_fabric_index", _m68_memory_fabric_index),
+    (69, "provider_runtime_metadata", _m69_provider_runtime_metadata),
 ]
 
 

package/src/db/_sessions.py

@@ -19,6 +19,16 @@ import re
 _SID_EXACT = re.compile(r'^nexo-\d+-\d+$')
 _SID_SEARCH = re.compile(r'nexo-\d+-\d+')
 
+
+def _provider_from_session_client(value: str | None) -> str:
+    candidate = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+    if candidate in {"anthropic", "claude", "claude_code", "claudecode"}:
+        return "anthropic"
+    if candidate in {"openai", "codex", "openai_codex"}:
+        return "openai"
+    return ""
+
+
 def _validate_sid(sid: str) -> str:
     """Validate and sanitize SID. Extracts clean SID if embedded in text."""
     if not sid:
@@ -41,6 +51,7 @@ def register_session(
     *,
     external_session_id: str = "",
     session_client: str = "",
+    session_provider: str = "",
     conversation_id: str = "",
 ) -> dict:
     """Register or re-register a session."""
@@ -48,27 +59,49 @@ def register_session(
     conn = get_db()
     now = now_epoch()
     linked_session_id = (external_session_id or claude_session_id or "").strip()
-    conn.execute(
-        "INSERT OR REPLACE INTO sessions (sid, task, started_epoch, last_update_epoch, local_time, claude_session_id, external_session_id, session_client, conversation_id) "
-        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
-        (
-            sid,
-            task,
-            now,
-            now,
-            local_time_str(),
-            linked_session_id,
-            linked_session_id,
-            (session_client or "").strip(),
-            (conversation_id or "").strip(),
+    provider = _provider_from_session_client(session_provider) or _provider_from_session_client(session_client)
+    try:
+        conn.execute(
+            "INSERT OR REPLACE INTO sessions (sid, task, started_epoch, last_update_epoch, local_time, claude_session_id, external_session_id, session_client, session_provider, conversation_id) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                sid,
+                task,
+                now,
+                now,
+                local_time_str(),
+                linked_session_id,
+                linked_session_id,
+                (session_client or "").strip(),
+                provider,
+                (conversation_id or "").strip(),
+            )
+        )
+    except sqlite3.OperationalError as exc:
+        if "session_provider" not in str(exc):
+            raise
+        conn.execute(
+            "INSERT OR REPLACE INTO sessions (sid, task, started_epoch, last_update_epoch, local_time, claude_session_id, external_session_id, session_client, conversation_id) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                sid,
+                task,
+                now,
+                now,
+                local_time_str(),
+                linked_session_id,
+                linked_session_id,
+                (session_client or "").strip(),
+                (conversation_id or "").strip(),
+            )
         )
-    )
     conn.commit()
     return {
         "sid": sid,
         "task": task,
         "external_session_id": linked_session_id,
         "session_client": (session_client or "").strip(),
+        "session_provider": provider,
         "conversation_id": (conversation_id or "").strip(),
     }
 
@@ -115,11 +148,20 @@ def get_active_sessions() -> list[dict]:
     """Get all sessions updated within STALE threshold."""
     conn = get_db()
     cutoff = now_epoch() - SESSION_STALE_SECONDS
-    rows = conn.execute(
-        "SELECT sid, task, started_epoch, last_update_epoch, local_time, conversation_id "
-        "FROM sessions WHERE last_update_epoch > ?",
-        (cutoff,)
-    ).fetchall()
+    try:
+        rows = conn.execute(
+            "SELECT sid, task, started_epoch, last_update_epoch, local_time, conversation_id, session_provider "
+            "FROM sessions WHERE last_update_epoch > ?",
+            (cutoff,)
+        ).fetchall()
+    except sqlite3.OperationalError as exc:
+        if "session_provider" not in str(exc):
+            raise
+        rows = conn.execute(
+            "SELECT sid, task, started_epoch, last_update_epoch, local_time, conversation_id "
+            "FROM sessions WHERE last_update_epoch > ?",
+            (cutoff,)
+        ).fetchall()
     return [dict(r) for r in rows]
 
 
@@ -248,11 +290,20 @@ def search_sessions(keyword: str) -> list[dict]:
     """Find sessions whose task contains keyword (case-insensitive)."""
     conn = get_db()
     cutoff = now_epoch() - SESSION_STALE_SECONDS
-    rows = conn.execute(
-        "SELECT sid, task, last_update_epoch, local_time, conversation_id FROM sessions "
-        "WHERE last_update_epoch > ? AND LOWER(task) LIKE ?",
-        (cutoff, f"%{keyword.lower()}%")
-    ).fetchall()
+    try:
+        rows = conn.execute(
+            "SELECT sid, task, last_update_epoch, local_time, conversation_id, session_provider FROM sessions "
+            "WHERE last_update_epoch > ? AND LOWER(task) LIKE ?",
+            (cutoff, f"%{keyword.lower()}%")
+        ).fetchall()
+    except sqlite3.OperationalError as exc:
+        if "session_provider" not in str(exc):
+            raise
+        rows = conn.execute(
+            "SELECT sid, task, last_update_epoch, local_time, conversation_id FROM sessions "
+            "WHERE last_update_epoch > ? AND LOWER(task) LIKE ?",
+            (cutoff, f"%{keyword.lower()}%")
+        ).fetchall()
     return [dict(r) for r in rows]
 
 

package/src/provider_runtime.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+"""Provider-runtime contract for Anthropic/Claude Code and OpenAI/Codex."""
+
+from client_preferences import (
+    BACKEND_NONE,
+    CLIENT_CLAUDE_CODE,
+    CLIENT_CODEX,
+    CLIENT_TO_PROVIDER,
+    PROVIDER_ANTHROPIC,
+    PROVIDER_NONE,
+    PROVIDER_OPENAI,
+    PROVIDER_TO_CLIENT,
+    client_to_provider,
+    default_provider_runtime,
+    normalize_provider_key,
+    normalize_provider_runtime,
+    provider_to_client,
+    resolve_automation_provider,
+    resolve_selected_chat_provider,
+)
+
+__all__ = [
+    "BACKEND_NONE",
+    "CLIENT_CLAUDE_CODE",
+    "CLIENT_CODEX",
+    "CLIENT_TO_PROVIDER",
+    "PROVIDER_ANTHROPIC",
+    "PROVIDER_NONE",
+    "PROVIDER_OPENAI",
+    "PROVIDER_TO_CLIENT",
+    "client_to_provider",
+    "default_provider_runtime",
+    "normalize_provider_key",
+    "normalize_provider_runtime",
+    "provider_to_client",
+    "resolve_automation_provider",
+    "resolve_selected_chat_provider",
+]

package/src/scripts/deep-sleep/extract.py

@@ -318,6 +318,7 @@ def analyze_session(
             output_format="text",
             append_system_prompt=json_system_prompt,
             allowed_tools="Read,Grep,Bash",
+            bare_mode=False,
         )
 
         if result.returncode != 0:
@@ -348,6 +349,7 @@ def analyze_session(
                 timeout=120,
                 output_format="text",
                 append_system_prompt=json_system_prompt,
+                bare_mode=False,
             )
             if convert_result.returncode == 0:
                 debug_output = convert_result.stdout

package/src/scripts/deep-sleep/synthesize.py

@@ -247,6 +247,7 @@ def main():
             timeout=CLAUDE_TIMEOUT,
             output_format="text",
             allowed_tools="Read,Grep,Bash",
+            bare_mode=False,
         )
 
         if result.returncode != 0: