nexo-brain 2.5.1 → 2.6.1

package/src/crons/sync.py

@@ -20,74 +20,159 @@ import json
 import os
 import platform
 import plistlib
+import shutil
 import subprocess
 import sys
 from pathlib import Path
 
+_CRONS_DIR = Path(__file__).resolve().parent
+_DEFAULT_RUNTIME_ROOT = _CRONS_DIR.parent
+_runtime_root = Path(os.environ.get("NEXO_CODE", str(_DEFAULT_RUNTIME_ROOT)))
+if str(_runtime_root) not in sys.path:
+    sys.path.insert(0, str(_runtime_root))
+
+from cron_recovery import should_run_at_load
+
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent.parent)))
+SOURCE_ROOT = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent.parent)))
+RUNTIME_ROOT = NEXO_HOME
 MANIFEST = Path(__file__).resolve().parent / "manifest.json"
 LAUNCH_AGENTS_DIR = Path.home() / "Library" / "LaunchAgents"
 LABEL_PREFIX = "com.nexo."
 LOG_DIR = NEXO_HOME / "logs"
+OPTIONALS_FILE = NEXO_HOME / "config" / "optionals.json"
+RETIRED_CORE_FILES = (
+    Path("scripts") / "nexo-day-orchestrator.sh",
+)
 
 
 def log(msg: str):
     print(f"[cron-sync] {msg}", flush=True)
 
 
+def _sync_watchdog_hash_registry():
+    """Keep the immutable-hash registry aligned with the runtime watchdog script."""
+    try:
+        watchdog_path = RUNTIME_ROOT / "scripts" / "nexo-watchdog.sh"
+        if not watchdog_path.exists():
+            return
+        registry_path = RUNTIME_ROOT / "scripts" / ".watchdog-hashes"
+        entries: dict[str, str] = {}
+        if registry_path.exists():
+            for line in registry_path.read_text().splitlines():
+                if "|" not in line:
+                    continue
+                file_path, expected_hash = line.split("|", 1)
+                if file_path:
+                    entries[file_path] = expected_hash
+        import hashlib
+        entries[str(watchdog_path)] = hashlib.sha256(watchdog_path.read_bytes()).hexdigest()
+        registry_path.write_text(
+            "\n".join(f"{file_path}|{digest}" for file_path, digest in sorted(entries.items())) + "\n"
+        )
+    except Exception as e:
+        log(f"WARNING: could not sync watchdog hash registry: {e}")
+
+
+def _refresh_runtime_manifest():
+    """Keep the installed crons manifest aligned with the source manifest."""
+    try:
+        runtime_manifest = RUNTIME_ROOT / "crons" / "manifest.json"
+        runtime_manifest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(MANIFEST, runtime_manifest)
+    except Exception as e:
+        log(f"WARNING: could not refresh runtime manifest: {e}")
+
+
+def _cleanup_retired_core_files():
+    """Remove retired core runtime files that should no longer survive updates."""
+    for rel_path in RETIRED_CORE_FILES:
+        try:
+            target = RUNTIME_ROOT / rel_path
+            if target.exists():
+                if target.is_dir():
+                    shutil.rmtree(target)
+                else:
+                    target.unlink()
+                log(f"  Removed retired core file: {rel_path}")
+        except Exception as e:
+            log(f"WARNING: could not remove retired core file {rel_path}: {e}")
+
+
 def load_manifest() -> list[dict]:
     with open(MANIFEST) as f:
         data = json.load(f)
-    return data.get("crons", [])
+    crons = data.get("crons", [])
+
+    enabled_optionals: dict[str, bool] = {}
+    if OPTIONALS_FILE.is_file():
+        try:
+            enabled_optionals = json.loads(OPTIONALS_FILE.read_text())
+        except Exception as e:
+            log(f"WARNING: could not read optionals.json: {e}")
+
+    filtered = []
+    for cron in crons:
+        optional_key = cron.get("optional")
+        if optional_key and not enabled_optionals.get(optional_key, False):
+            continue
+        filtered.append(cron)
+    return filtered
+
+
+def _runtime_relative_path(src: Path) -> Path:
+    """Return the path inside NEXO_HOME that mirrors the source tree."""
+    src = src.resolve()
+    try:
+        return src.relative_to(SOURCE_ROOT.resolve())
+    except Exception:
+        # Best effort fallback for unexpected inputs.
+        return Path("scripts") / src.name
 
 
-def _copy_script_to_nexo_home(src: Path) -> Path:
-    """Copy a script from NEXO_CODE to NEXO_HOME/scripts/ for Sandbox compatibility.
+def _copy_into_runtime(src: Path) -> Path:
+    """Copy a script or directory from the source tree into NEXO_HOME.
 
-    macOS Sandbox blocks LaunchAgents from executing scripts in ~/Documents/.
-    We copy scripts to NEXO_HOME/scripts/ which is outside the Sandbox restricted paths.
+    LaunchAgents should execute from NEXO_HOME, not directly from repo paths
+    under macOS-protected folders such as ~/Documents.
     """
-    dest_dir = NEXO_HOME / "scripts"
-    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = RUNTIME_ROOT / _runtime_relative_path(src)
+    dest.parent.mkdir(parents=True, exist_ok=True)
 
     if src.is_dir():
-        import shutil
-        dest = dest_dir / src.name
         if dest.exists():
             shutil.rmtree(dest)
         shutil.copytree(src, dest)
         return dest
-    else:
-        dest = dest_dir / src.name
-        import shutil
-        shutil.copy2(src, dest)
+
+    shutil.copy2(src, dest)
+    if src.suffix in {".sh", ".py"} or os.access(src, os.X_OK):
         dest.chmod(0o755)
-        return dest
+    return dest
 
 
 def build_plist(cron: dict) -> dict:
     """Build a macOS LaunchAgent plist dict from a manifest entry."""
     cron_id = cron["id"]
     label = f"{LABEL_PREFIX}{cron_id}"
-    script_src = NEXO_CODE / cron["script"]
+    script_src = SOURCE_ROOT / cron["script"]
     script_type = cron.get("type", "python")
 
-    # Copy scripts to NEXO_HOME/scripts/ to avoid macOS Sandbox restrictions
-    script_dest = _copy_script_to_nexo_home(script_src)
+    # Copy scripts into NEXO_HOME preserving the source tree layout.
+    script_dest = _copy_into_runtime(script_src)
     script_path = str(script_dest)
 
     # Also copy the wrapper and any subdirectories (e.g., deep-sleep/)
-    wrapper_src = NEXO_CODE / "scripts" / "nexo-cron-wrapper.sh"
-    wrapper_dest = _copy_script_to_nexo_home(wrapper_src)
+    wrapper_src = SOURCE_ROOT / "scripts" / "nexo-cron-wrapper.sh"
+    wrapper_dest = _copy_into_runtime(wrapper_src)
     wrapper_path = str(wrapper_dest)
 
     # Copy script subdirectories if they exist (e.g., deep-sleep/ for nexo-deep-sleep.sh)
     script_name = script_src.stem  # e.g., "nexo-deep-sleep"
     subdir_name = script_name.replace("nexo-", "")  # e.g., "deep-sleep"
-    subdir_src = NEXO_CODE / "scripts" / subdir_name
+    subdir_src = SOURCE_ROOT / "scripts" / subdir_name
     if subdir_src.is_dir():
-        _copy_script_to_nexo_home(subdir_src)
+        _copy_into_runtime(subdir_src)
 
     if script_type == "shell":
         program_args = ["/bin/bash", wrapper_path, cron_id, "/bin/bash", script_path]
@@ -118,17 +203,23 @@ def build_plist(cron: dict) -> dict:
                     + "/Library/Frameworks/Python.framework/Versions/3.12/bin",
             "HOME": str(Path.home()),
             "NEXO_HOME": str(NEXO_HOME),
-            "NEXO_CODE": str(NEXO_CODE),
+            "NEXO_CODE": str(RUNTIME_ROOT),
+            "NEXO_SOURCE_CODE": str(SOURCE_ROOT),
+            "NEXO_MANAGED_CORE_CRON": "1",
             "PYTHONUNBUFFERED": "1",
         },
     }
 
     # Schedule
-    if cron.get("run_at_load"):
+    if cron.get("keep_alive"):
         plist["RunAtLoad"] = True
-    elif "interval_seconds" in cron:
+        plist["KeepAlive"] = True
+    else:
+        if should_run_at_load(cron):
+            plist["RunAtLoad"] = True
+    if "interval_seconds" in cron and not cron.get("keep_alive"):
         plist["StartInterval"] = cron["interval_seconds"]
-    elif "schedule" in cron:
+    elif "schedule" in cron and not cron.get("keep_alive"):
         cal = {}
         s = cron["schedule"]
         if "hour" in s:
@@ -170,6 +261,10 @@ def plist_needs_update(existing_path: Path, new_plist: dict) -> bool:
         return True
     if existing.get("RunAtLoad") != new_plist.get("RunAtLoad"):
         return True
+    if existing.get("KeepAlive") != new_plist.get("KeepAlive"):
+        return True
+    if existing.get("EnvironmentVariables") != new_plist.get("EnvironmentVariables"):
+        return True
     return False
 
 
@@ -244,8 +339,15 @@ def sync(dry_run: bool = False):
             try:
                 with open(plist_path, "rb") as f:
                     existing = plistlib.load(f)
+                env = existing.get("EnvironmentVariables", {}) or {}
                 args = existing.get("ProgramArguments", [])
-                is_core = any(str(NEXO_CODE) in str(a) for a in args)
+                is_core = env.get("NEXO_MANAGED_CORE_CRON") == "1"
+                if not is_core:
+                    arg_blob = " ".join(str(a) for a in args)
+                    is_core = (
+                        "nexo-cron-wrapper.sh" in arg_blob
+                        and (str(SOURCE_ROOT) in arg_blob or str(NEXO_HOME) in arg_blob)
+                    )
             except Exception:
                 is_core = False
 
@@ -255,6 +357,9 @@ def sync(dry_run: bool = False):
             else:
                 log(f"  SKIP (personal): {cron_id}")
 
+    _cleanup_retired_core_files()
+    _refresh_runtime_manifest()
+    _sync_watchdog_hash_registry()
     log("Sync complete.")
 
 
@@ -265,7 +370,7 @@ def sync_linux(dry_run: bool = False):
     LOG_DIR.mkdir(parents=True, exist_ok=True)
 
     manifest_crons = load_manifest()
-    wrapper_src = NEXO_CODE / "scripts" / "nexo-cron-wrapper.sh"
+    wrapper_src = SOURCE_ROOT / "scripts" / "nexo-cron-wrapper.sh"
     wrapper_dest = _copy_script_to_nexo_home(wrapper_src)
 
     log(f"Manifest: {len(manifest_crons)} core crons")
@@ -278,13 +383,13 @@ def sync_linux(dry_run: bool = False):
 
     for cron in manifest_crons:
         cron_id = cron["id"]
-        script_src = NEXO_CODE / cron["script"]
+        script_src = SOURCE_ROOT / cron["script"]
         script_dest = _copy_script_to_nexo_home(script_src)
         script_type = cron.get("type", "python")
 
         # Copy subdirectories
         subdir_name = script_src.stem.replace("nexo-", "")
-        subdir_src = NEXO_CODE / "scripts" / subdir_name
+        subdir_src = SOURCE_ROOT / "scripts" / subdir_name
         if subdir_src.is_dir():
             _copy_script_to_nexo_home(subdir_src)
 
@@ -306,7 +411,7 @@ Description=NEXO: {cron.get('description', cron_id)}
 Type=oneshot
 ExecStart={exec_cmd}
 Environment=NEXO_HOME={NEXO_HOME}
-Environment=NEXO_CODE={NEXO_CODE}
+Environment=NEXO_CODE={SOURCE_ROOT}
 Environment=HOME={Path.home()}
 StandardOutput=append:{stdout_log}
 StandardError=append:{stderr_log}

package/src/db/__init__.py

@@ -93,6 +93,17 @@ from db._cron_runs import (
     cron_run_start, cron_run_end, cron_runs_recent, cron_runs_summary,
 )
 
+# Personal scripts registry
+from db._personal_scripts import (
+    upsert_personal_script, list_personal_scripts, get_personal_script,
+    delete_missing_personal_scripts, register_personal_script_schedule,
+    delete_missing_personal_schedules, list_personal_script_schedules,
+    get_personal_script_schedule, delete_personal_script_schedule,
+    delete_personal_script,
+    record_personal_script_run, sync_personal_scripts_registry,
+    get_personal_script_health_report,
+)
+
 # Skills
 from db._skills import (
     create_skill, get_skill, list_skills, search_skills,