nexo-brain 2.1.0 → 2.3.0

package/src/crons/sync 2.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""
+NEXO Cron Sync — Synchronize crons/manifest.json with system LaunchAgents (macOS).
+
+Called by nexo_update after pulling new code. Ensures:
+- New crons in manifest → installed
+- Removed crons from manifest → unloaded + deleted
+- Changed schedule/interval → plist updated + reloaded
+- Personal (non-core) crons → left untouched
+
+Usage:
+  python3 crons/sync.py [--dry-run]
+
+Environment:
+  NEXO_HOME — root of NEXO installation
+  NEXO_CODE — path to NEXO source (defaults to script parent's parent)
+"""
+
+import json
+import os
+import platform
+import plistlib
+import subprocess
+import sys
+from pathlib import Path
+
+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)))
+MANIFEST = Path(__file__).resolve().parent / "manifest.json"
+LAUNCH_AGENTS_DIR = Path.home() / "Library" / "LaunchAgents"
+LABEL_PREFIX = "com.nexo."
+LOG_DIR = NEXO_HOME / "logs"
+
+
+def log(msg: str):
+    print(f"[cron-sync] {msg}", flush=True)
+
+
+def load_manifest() -> list[dict]:
+    with open(MANIFEST) as f:
+        data = json.load(f)
+    return data.get("crons", [])
+
+
+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_path = str(NEXO_CODE / cron["script"])
+    script_type = cron.get("type", "python")
+
+    if script_type == "shell":
+        program_args = ["/bin/bash", script_path]
+    else:
+        # Find python3
+        python_candidates = [
+            "/opt/homebrew/bin/python3",
+            "/usr/local/bin/python3",
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3",
+            "/usr/bin/python3",
+        ]
+        python_bin = "python3"
+        for p in python_candidates:
+            if Path(p).exists():
+                python_bin = p
+                break
+        program_args = [python_bin, script_path]
+
+    plist = {
+        "Label": label,
+        "ProgramArguments": program_args,
+        "StandardOutPath": str(LOG_DIR / f"{cron_id}-stdout.log"),
+        "StandardErrorPath": str(LOG_DIR / f"{cron_id}-stderr.log"),
+        "EnvironmentVariables": {
+            "PATH": "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:"
+                    + str(Path.home() / ".local" / "bin") + ":"
+                    + str(Path.home() / ".nvm/versions/node/v22.14.0/bin") + ":"
+                    + "/Library/Frameworks/Python.framework/Versions/3.12/bin",
+            "HOME": str(Path.home()),
+            "NEXO_HOME": str(NEXO_HOME),
+            "NEXO_CODE": str(NEXO_CODE),
+            "PYTHONUNBUFFERED": "1",
+        },
+    }
+
+    # Schedule
+    if "interval_seconds" in cron:
+        plist["StartInterval"] = cron["interval_seconds"]
+    elif "schedule" in cron:
+        cal = {}
+        s = cron["schedule"]
+        if "hour" in s:
+            cal["Hour"] = s["hour"]
+        if "minute" in s:
+            cal["Minute"] = s["minute"]
+        if "weekday" in s:
+            cal["Weekday"] = s["weekday"]
+        plist["StartCalendarInterval"] = cal
+
+    return plist
+
+
+def get_installed_nexo_crons() -> dict[str, Path]:
+    """Return dict of cron_id → plist_path for installed NEXO crons."""
+    installed = {}
+    if not LAUNCH_AGENTS_DIR.exists():
+        return installed
+    for f in LAUNCH_AGENTS_DIR.glob(f"{LABEL_PREFIX}*.plist"):
+        cron_id = f.stem.replace(LABEL_PREFIX, "")
+        installed[cron_id] = f
+    return installed
+
+
+def plist_needs_update(existing_path: Path, new_plist: dict) -> bool:
+    """Check if the installed plist differs from what we'd generate."""
+    try:
+        with open(existing_path, "rb") as f:
+            existing = plistlib.load(f)
+    except Exception:
+        return True
+
+    # Compare key fields
+    if existing.get("ProgramArguments") != new_plist.get("ProgramArguments"):
+        return True
+    if existing.get("StartInterval") != new_plist.get("StartInterval"):
+        return True
+    if existing.get("StartCalendarInterval") != new_plist.get("StartCalendarInterval"):
+        return True
+    return False
+
+
+def install_plist(label: str, plist: dict, plist_path: Path, dry_run: bool):
+    """Write plist and load it."""
+    if dry_run:
+        log(f"  DRY-RUN: would install {plist_path.name}")
+        return
+
+    # Unload if already loaded
+    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+
+    with open(plist_path, "wb") as f:
+        plistlib.dump(plist, f)
+
+    subprocess.run(["launchctl", "load", str(plist_path)], capture_output=True)
+    log(f"  Installed + loaded: {plist_path.name}")
+
+
+def unload_plist(plist_path: Path, dry_run: bool):
+    """Unload and remove a plist."""
+    if dry_run:
+        log(f"  DRY-RUN: would remove {plist_path.name}")
+        return
+
+    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+    plist_path.unlink(missing_ok=True)
+    log(f"  Removed: {plist_path.name}")
+
+
+def sync(dry_run: bool = False):
+    if platform.system() != "Darwin":
+        log("Not macOS — cron sync only supports LaunchAgents. Skipping.")
+        return
+
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    LAUNCH_AGENTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    manifest_crons = load_manifest()
+    manifest_ids = {c["id"] for c in manifest_crons}
+    installed = get_installed_nexo_crons()
+
+    log(f"Manifest: {len(manifest_crons)} core crons")
+    log(f"Installed: {len(installed)} NEXO crons")
+
+    # 1. Install or update crons from manifest
+    for cron in manifest_crons:
+        cron_id = cron["id"]
+        label = f"{LABEL_PREFIX}{cron_id}"
+        plist_path = LAUNCH_AGENTS_DIR / f"{label}.plist"
+        new_plist = build_plist(cron)
+
+        if cron_id not in installed:
+            log(f"  NEW: {cron_id}")
+            install_plist(label, new_plist, plist_path, dry_run)
+        elif plist_needs_update(installed[cron_id], new_plist):
+            log(f"  UPDATE: {cron_id}")
+            install_plist(label, new_plist, plist_path, dry_run)
+        else:
+            log(f"  OK: {cron_id}")
+
+    # 2. Remove crons that are in installed but NOT in manifest and ARE core
+    #    (personal crons like shopify-backup, email-monitor are left alone)
+    for cron_id, plist_path in installed.items():
+        if cron_id not in manifest_ids:
+            # Check if this was previously a core cron by reading the plist
+            # If it points to NEXO_CODE scripts → it's core, safe to remove
+            try:
+                with open(plist_path, "rb") as f:
+                    existing = plistlib.load(f)
+                args = existing.get("ProgramArguments", [])
+                is_core = any(str(NEXO_CODE) in str(a) for a in args)
+            except Exception:
+                is_core = False
+
+            if is_core:
+                log(f"  REMOVE (no longer in manifest): {cron_id}")
+                unload_plist(plist_path, dry_run)
+            else:
+                log(f"  SKIP (personal): {cron_id}")
+
+    log("Sync complete.")
+
+
+if __name__ == "__main__":
+    dry_run = "--dry-run" in sys.argv
+    if dry_run:
+        log("DRY RUN MODE — no changes will be made")
+    sync(dry_run=dry_run)

package/src/crons/sync.py

@@ -42,15 +42,56 @@ def load_manifest() -> list[dict]:
     return data.get("crons", [])
 
 
+def _copy_script_to_nexo_home(src: Path) -> Path:
+    """Copy a script from NEXO_CODE to NEXO_HOME/scripts/ for Sandbox compatibility.
+
+    macOS Sandbox blocks LaunchAgents from executing scripts in ~/Documents/.
+    We copy scripts to NEXO_HOME/scripts/ which is typically ~/claude/scripts/
+    or ~/.nexo/scripts/ — both outside the Sandbox restricted paths.
+    """
+    dest_dir = NEXO_HOME / "scripts"
+    dest_dir.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)
+        dest.chmod(0o755)
+        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_path = str(NEXO_CODE / cron["script"])
+    script_src = NEXO_CODE / 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)
+    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_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
+    if subdir_src.is_dir():
+        _copy_script_to_nexo_home(subdir_src)
+
     if script_type == "shell":
-        program_args = ["/bin/bash", script_path]
+        program_args = ["/bin/bash", wrapper_path, cron_id, "/bin/bash", script_path]
     else:
         # Find python3
         python_candidates = [
@@ -64,7 +105,7 @@ def build_plist(cron: dict) -> dict:
             if Path(p).exists():
                 python_bin = p
                 break
-        program_args = [python_bin, script_path]
+        program_args = ["/bin/bash", wrapper_path, cron_id, python_bin, script_path]
 
     plist = {
         "Label": label,
@@ -84,7 +125,9 @@ def build_plist(cron: dict) -> dict:
     }
 
     # Schedule
-    if "interval_seconds" in cron:
+    if cron.get("run_at_load"):
+        plist["RunAtLoad"] = True
+    elif "interval_seconds" in cron:
         plist["StartInterval"] = cron["interval_seconds"]
     elif "schedule" in cron:
         cal = {}
@@ -126,6 +169,8 @@ def plist_needs_update(existing_path: Path, new_plist: dict) -> bool:
         return True
     if existing.get("StartCalendarInterval") != new_plist.get("StartCalendarInterval"):
         return True
+    if existing.get("RunAtLoad") != new_plist.get("RunAtLoad"):
+        return True
     return False
 
 
@@ -157,8 +202,12 @@ def unload_plist(plist_path: Path, dry_run: bool):
 
 
 def sync(dry_run: bool = False):
-    if platform.system() != "Darwin":
-        log("Not macOS — cron sync only supports LaunchAgents. Skipping.")
+    system = platform.system()
+    if system == "Linux":
+        sync_linux(dry_run)
+        return
+    if system != "Darwin":
+        log(f"Unsupported platform: {system}. Skipping.")
         return
 
     LOG_DIR.mkdir(parents=True, exist_ok=True)
@@ -210,6 +259,102 @@ def sync(dry_run: bool = False):
     log("Sync complete.")
 
 
+def sync_linux(dry_run: bool = False):
+    """Sync manifest to systemd user timers (Linux)."""
+    unit_dir = Path.home() / ".config" / "systemd" / "user"
+    unit_dir.mkdir(parents=True, exist_ok=True)
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    manifest_crons = load_manifest()
+    wrapper_src = NEXO_CODE / "scripts" / "nexo-cron-wrapper.sh"
+    wrapper_dest = _copy_script_to_nexo_home(wrapper_src)
+
+    log(f"Manifest: {len(manifest_crons)} core crons")
+
+    python_bin = "/usr/bin/python3"
+    for p in ["/usr/bin/python3", "/usr/local/bin/python3"]:
+        if Path(p).exists():
+            python_bin = p
+            break
+
+    for cron in manifest_crons:
+        cron_id = cron["id"]
+        script_src = NEXO_CODE / 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
+        if subdir_src.is_dir():
+            _copy_script_to_nexo_home(subdir_src)
+
+        if script_type == "shell":
+            exec_cmd = f"/bin/bash {wrapper_dest} {cron_id} /bin/bash {script_dest}"
+        else:
+            exec_cmd = f"/bin/bash {wrapper_dest} {cron_id} {python_bin} {script_dest}"
+
+        service_path = unit_dir / f"nexo-{cron_id}.service"
+        timer_path = unit_dir / f"nexo-{cron_id}.timer"
+
+        service_content = f"""[Unit]
+Description=NEXO: {cron.get('description', cron_id)}
+
+[Service]
+Type=oneshot
+ExecStart={exec_cmd}
+Environment=NEXO_HOME={NEXO_HOME}
+Environment=NEXO_CODE={NEXO_CODE}
+Environment=HOME={Path.home()}
+"""
+
+        if cron.get("run_at_load"):
+            timer_spec = "OnBootSec=0"
+        elif "interval_seconds" in cron:
+            timer_spec = f"OnUnitActiveSec={cron['interval_seconds']}s\nOnBootSec=60s"
+        elif "schedule" in cron:
+            s = cron["schedule"]
+            h, m = s.get("hour", 0), s.get("minute", 0)
+            if "weekday" in s:
+                days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+                timer_spec = f"OnCalendar={days[s['weekday']]} *-*-* {h:02d}:{m:02d}:00"
+            else:
+                timer_spec = f"OnCalendar=*-*-* {h:02d}:{m:02d}:00"
+        else:
+            log(f"  SKIP {cron_id}: no schedule or interval")
+            continue
+
+        timer_content = f"""[Unit]
+Description=NEXO timer: {cron.get('description', cron_id)}
+
+[Timer]
+{timer_spec}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+"""
+
+        if dry_run:
+            log(f"  DRY-RUN: would install {cron_id}")
+            continue
+
+        service_path.write_text(service_content)
+        timer_path.write_text(timer_content)
+        log(f"  Installed: {cron_id}")
+
+    if not dry_run:
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+        for cron in manifest_crons:
+            subprocess.run(
+                ["systemctl", "--user", "enable", "--now", f"nexo-{cron['id']}.timer"],
+                capture_output=True
+            )
+        log("systemd timers enabled.")
+
+    log("Sync complete.")
+
+
 if __name__ == "__main__":
     dry_run = "--dry-run" in sys.argv
     if dry_run: