nexo-brain 2.6.1 → 2.6.3

package/src/runtime_power.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+"""Runtime power policy helpers.
+
+Manages the optional "prevent sleep" helper as an explicit, persisted runtime
+preference. The policy is stored in config/schedule.json to avoid introducing a
+second user-facing config surface.
+"""
+
+import json
+import os
+import platform
+import plistlib
+import subprocess
+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)))
+CONFIG_DIR = NEXO_HOME / "config"
+SCHEDULE_FILE = CONFIG_DIR / "schedule.json"
+POWER_POLICY_KEY = "power_policy"
+POWER_POLICY_VERSION_KEY = "power_policy_version"
+POWER_POLICY_VERSION = 1
+POWER_POLICY_ALWAYS_ON = "always_on"
+POWER_POLICY_DISABLED = "disabled"
+POWER_POLICY_UNSET = "unset"
+VALID_POWER_POLICIES = {
+    POWER_POLICY_ALWAYS_ON,
+    POWER_POLICY_DISABLED,
+    POWER_POLICY_UNSET,
+}
+LAUNCH_AGENTS_DIR = Path.home() / "Library" / "LaunchAgents"
+LINUX_SYSTEMD_USER_DIR = Path.home() / ".config" / "systemd" / "user"
+
+
+def _schedule_defaults() -> dict:
+    return {
+        "timezone": "UTC",
+        "auto_update": True,
+        POWER_POLICY_KEY: POWER_POLICY_UNSET,
+        POWER_POLICY_VERSION_KEY: POWER_POLICY_VERSION,
+        "processes": {},
+    }
+
+
+def load_schedule_config() -> dict:
+    if not SCHEDULE_FILE.is_file():
+        return _schedule_defaults()
+    try:
+        data = json.loads(SCHEDULE_FILE.read_text())
+    except Exception:
+        return _schedule_defaults()
+    if not isinstance(data, dict):
+        return _schedule_defaults()
+    merged = _schedule_defaults()
+    merged.update(data)
+    merged.setdefault("processes", {})
+    return merged
+
+
+def save_schedule_config(schedule: dict) -> Path:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    payload = dict(_schedule_defaults())
+    payload.update(schedule or {})
+    payload.setdefault("processes", {})
+    payload[POWER_POLICY_KEY] = normalize_power_policy(payload.get(POWER_POLICY_KEY))
+    payload[POWER_POLICY_VERSION_KEY] = POWER_POLICY_VERSION
+    SCHEDULE_FILE.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+    return SCHEDULE_FILE
+
+
+def normalize_power_policy(value: str | None) -> str:
+    candidate = str(value or "").strip().lower()
+    if candidate in {"enabled", "yes", "on", "true", "1"}:
+        return POWER_POLICY_ALWAYS_ON
+    if candidate in {"disabled", "no", "off", "false", "0"}:
+        return POWER_POLICY_DISABLED
+    if candidate in VALID_POWER_POLICIES:
+        return candidate
+    return POWER_POLICY_UNSET
+
+
+def get_power_policy(schedule: dict | None = None) -> str:
+    schedule = schedule or load_schedule_config()
+    return normalize_power_policy(schedule.get(POWER_POLICY_KEY))
+
+
+def is_power_policy_configured(schedule: dict | None = None) -> bool:
+    return get_power_policy(schedule) != POWER_POLICY_UNSET
+
+
+def set_power_policy(policy: str) -> dict:
+    schedule = load_schedule_config()
+    schedule[POWER_POLICY_KEY] = normalize_power_policy(policy)
+    schedule[POWER_POLICY_VERSION_KEY] = POWER_POLICY_VERSION
+    save_schedule_config(schedule)
+    return schedule
+
+
+def prompt_for_power_policy(
+    *,
+    reason: str = "install",
+    input_fn=input,
+    output_fn=print,
+) -> str:
+    prompt = (
+        "[NEXO] Keep this machine awake for background work? "
+        "[y]es / [n]o / [l]ater: "
+    )
+    output_fn(
+        "[NEXO] This controls the optional prevent-sleep helper. "
+        "It improves background availability but should remain opt-in."
+    )
+    while True:
+        answer = str(input_fn(prompt)).strip().lower()
+        if answer in {"y", "yes"}:
+            return POWER_POLICY_ALWAYS_ON
+        if answer in {"n", "no"}:
+            return POWER_POLICY_DISABLED
+        if answer in {"l", "later", ""}:
+            return POWER_POLICY_UNSET
+        output_fn("[NEXO] Reply with yes, no, or later.")
+
+
+def ensure_power_policy_choice(
+    *,
+    interactive: bool,
+    reason: str = "update",
+    input_fn=input,
+    output_fn=print,
+) -> dict:
+    schedule = load_schedule_config()
+    policy = get_power_policy(schedule)
+    prompted = False
+    if interactive and policy == POWER_POLICY_UNSET:
+        prompted = True
+        policy = prompt_for_power_policy(reason=reason, input_fn=input_fn, output_fn=output_fn)
+        schedule[POWER_POLICY_KEY] = policy
+        schedule[POWER_POLICY_VERSION_KEY] = POWER_POLICY_VERSION
+        save_schedule_config(schedule)
+    return {
+        "policy": policy,
+        "prompted": prompted,
+        "schedule_file": str(SCHEDULE_FILE),
+    }
+
+
+def _prevent_sleep_script_path() -> Path:
+    runtime_script = NEXO_HOME / "scripts" / "nexo-prevent-sleep.sh"
+    if runtime_script.is_file():
+        return runtime_script
+    source_script = NEXO_CODE / "scripts" / "nexo-prevent-sleep.sh"
+    return source_script
+
+
+def _macos_prevent_sleep_plist() -> tuple[Path, dict]:
+    script_path = _prevent_sleep_script_path()
+    plist_path = LAUNCH_AGENTS_DIR / "com.nexo.prevent-sleep.plist"
+    plist = {
+        "Label": "com.nexo.prevent-sleep",
+        "ProgramArguments": ["/bin/bash", str(script_path)],
+        "RunAtLoad": True,
+        "KeepAlive": True,
+        "StandardOutPath": str(NEXO_HOME / "logs" / "prevent-sleep-stdout.log"),
+        "StandardErrorPath": str(NEXO_HOME / "logs" / "prevent-sleep-stderr.log"),
+        "EnvironmentVariables": {
+            "HOME": str(Path.home()),
+            "NEXO_HOME": str(NEXO_HOME),
+            "NEXO_CODE": str(NEXO_HOME),
+            "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:" + str(Path.home() / ".local/bin"),
+        },
+    }
+    return plist_path, plist
+
+
+def _linux_prevent_sleep_service() -> tuple[Path, str]:
+    script_path = _prevent_sleep_script_path()
+    service_path = LINUX_SYSTEMD_USER_DIR / "nexo-prevent-sleep.service"
+    body = f"""[Unit]
+Description=NEXO prevent sleep
+
+[Service]
+Type=simple
+ExecStart=/bin/bash {script_path}
+Environment=HOME={Path.home()}
+Environment=NEXO_HOME={NEXO_HOME}
+Environment=NEXO_CODE={NEXO_HOME}
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+"""
+    return service_path, body
+
+
+def apply_power_policy(policy: str | None = None) -> dict:
+    policy = normalize_power_policy(policy or get_power_policy())
+    system = platform.system()
+    logs_dir = NEXO_HOME / "logs"
+    logs_dir.mkdir(parents=True, exist_ok=True)
+
+    if system == "Darwin":
+        return _apply_macos_power_policy(policy)
+    if system == "Linux":
+        return _apply_linux_power_policy(policy)
+    return {
+        "ok": policy != POWER_POLICY_ALWAYS_ON,
+        "policy": policy,
+        "platform": system,
+        "action": "unsupported",
+        "message": f"Unsupported platform for prevent-sleep policy: {system}",
+    }
+
+
+def _apply_macos_power_policy(policy: str) -> dict:
+    plist_path, plist = _macos_prevent_sleep_plist()
+    label = plist["Label"]
+    uid = str(os.getuid())
+    if policy == POWER_POLICY_ALWAYS_ON:
+        LAUNCH_AGENTS_DIR.mkdir(parents=True, exist_ok=True)
+        with plist_path.open("wb") as fh:
+            plistlib.dump(plist, fh)
+        subprocess.run(["launchctl", "bootout", f"gui/{uid}", str(plist_path)], capture_output=True)
+        result = subprocess.run(
+            ["launchctl", "bootstrap", f"gui/{uid}", str(plist_path)],
+            capture_output=True,
+            text=True,
+        )
+        ok = result.returncode == 0
+        return {
+            "ok": ok,
+            "policy": policy,
+            "platform": "Darwin",
+            "action": "enabled",
+            "plist_path": str(plist_path),
+            "message": "" if ok else (result.stderr.strip() or result.stdout.strip()),
+        }
+
+    subprocess.run(["launchctl", "bootout", f"gui/{uid}", str(plist_path)], capture_output=True)
+    if plist_path.exists():
+        plist_path.unlink()
+    subprocess.run(["launchctl", "remove", label], capture_output=True)
+    return {
+        "ok": True,
+        "policy": policy,
+        "platform": "Darwin",
+        "action": "disabled" if policy == POWER_POLICY_DISABLED else "deferred",
+        "plist_path": str(plist_path),
+    }
+
+
+def _apply_linux_power_policy(policy: str) -> dict:
+    service_path, service_body = _linux_prevent_sleep_service()
+    if policy == POWER_POLICY_ALWAYS_ON:
+        LINUX_SYSTEMD_USER_DIR.mkdir(parents=True, exist_ok=True)
+        service_path.write_text(service_body)
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+        result = subprocess.run(
+            ["systemctl", "--user", "enable", "--now", "nexo-prevent-sleep.service"],
+            capture_output=True,
+            text=True,
+        )
+        ok = result.returncode == 0
+        return {
+            "ok": ok,
+            "policy": policy,
+            "platform": "Linux",
+            "action": "enabled",
+            "service_path": str(service_path),
+            "message": "" if ok else (result.stderr.strip() or result.stdout.strip()),
+        }
+
+    subprocess.run(["systemctl", "--user", "disable", "--now", "nexo-prevent-sleep.service"], capture_output=True)
+    if service_path.exists():
+        service_path.unlink()
+    subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+    return {
+        "ok": True,
+        "policy": policy,
+        "platform": "Linux",
+        "action": "disabled" if policy == POWER_POLICY_DISABLED else "deferred",
+        "service_path": str(service_path),
+    }

package/src/script_registry.py

@@ -58,9 +58,15 @@ METADATA_KEYS = {
     "schedule",
     "interval_seconds",
     "schedule_required",
+    "recovery_policy",
+    "run_on_boot",
+    "run_on_wake",
+    "idempotent",
+    "max_catchup_age",
 }
 SUPPORTED_RUNTIMES = {"python", "shell", "node", "php", "unknown"}
 PERSONAL_SCHEDULE_MANAGED_ENV = "NEXO_MANAGED_PERSONAL_CRON"
+SUPPORTED_RECOVERY_POLICIES = {"none", "run_once_on_wake", "catchup", "restart", "restart_daemon"}
 
 
 def get_nexo_home() -> Path:
@@ -214,8 +220,40 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
     interval_raw = metadata.get("interval_seconds", "").strip()
     schedule_raw = metadata.get("schedule", "").strip()
     schedule_required = _truthy(metadata.get("schedule_required"))
+    recovery_policy_raw = metadata.get("recovery_policy", "").strip().lower()
+    run_on_boot = _truthy(metadata.get("run_on_boot"))
+    run_on_wake = _truthy(metadata.get("run_on_wake"))
+    idempotent = _truthy(metadata.get("idempotent"))
+    max_catchup_age_raw = metadata.get("max_catchup_age", "").strip()
     required = schedule_required or bool(interval_raw or schedule_raw)
 
+    if recovery_policy_raw and recovery_policy_raw not in SUPPORTED_RECOVERY_POLICIES:
+        return {
+            "required": required,
+            "valid": False,
+            "error": f"Invalid recovery_policy: {recovery_policy_raw}",
+            "cron_id": cron_id,
+        }
+
+    max_catchup_age = 0
+    if max_catchup_age_raw:
+        try:
+            max_catchup_age = int(max_catchup_age_raw)
+        except ValueError:
+            return {
+                "required": required,
+                "valid": False,
+                "error": f"Invalid max_catchup_age: {max_catchup_age_raw}",
+                "cron_id": cron_id,
+            }
+        if max_catchup_age < 0:
+            return {
+                "required": required,
+                "valid": False,
+                "error": f"max_catchup_age must be >= 0 (got {max_catchup_age_raw})",
+                "cron_id": cron_id,
+            }
+
     if required:
         missing = []
         if not explicit_name:
@@ -241,6 +279,16 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
                 "cron_id": cron_id,
             }
 
+    def _effective_run_on_wake(policy: str) -> bool:
+        if "run_on_wake" in metadata:
+            return run_on_wake
+        return policy in {"catchup", "run_once_on_wake"}
+
+    def _effective_idempotent(policy: str) -> bool:
+        if "idempotent" in metadata:
+            return idempotent
+        return policy in {"catchup", "run_once_on_wake", "restart", "restart_daemon"}
+
     if interval_raw and schedule_raw:
         return {
             "required": required,
@@ -275,6 +323,11 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
             "schedule_label": f"every {interval}s",
             "schedule": "",
             "interval_seconds": interval,
+            "recovery_policy": recovery_policy_raw or "run_once_on_wake",
+            "run_on_boot": run_on_boot,
+            "run_on_wake": _effective_run_on_wake(recovery_policy_raw or "run_once_on_wake"),
+            "idempotent": _effective_idempotent(recovery_policy_raw or "run_once_on_wake"),
+            "max_catchup_age": max_catchup_age or max(interval * 4, interval + 900),
         }
 
     if schedule_raw:
@@ -325,6 +378,11 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
             "schedule_label": label,
             "schedule": schedule_raw,
             "interval_seconds": 0,
+            "recovery_policy": recovery_policy_raw or "catchup",
+            "run_on_boot": run_on_boot,
+            "run_on_wake": _effective_run_on_wake(recovery_policy_raw or "catchup"),
+            "idempotent": _effective_idempotent(recovery_policy_raw or "catchup"),
+            "max_catchup_age": max_catchup_age or (14 * 86400 if weekday is not None else 48 * 3600),
         }
 
     return {
@@ -332,6 +390,11 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
         "valid": not required,
         "error": "" if not required else "schedule_required=true but no schedule metadata was provided.",
         "cron_id": cron_id,
+        "recovery_policy": recovery_policy_raw or "none",
+        "run_on_boot": run_on_boot,
+        "run_on_wake": run_on_wake,
+        "idempotent": idempotent,
+        "max_catchup_age": max_catchup_age,
     }
 
 
@@ -580,6 +643,7 @@ def _discover_personal_schedule_records() -> list[dict]:
             "schedule_type": schedule_type,
             "schedule_value": schedule_value,
             "schedule_label": schedule_label,
+            "run_at_load": bool(plist_data.get("RunAtLoad")),
             "launchd_label": label,
             "plist_path": str(plist_path),
             "enabled": True,
@@ -766,6 +830,8 @@ def _schedule_matches(existing: dict, declared: dict) -> bool:
     declared_value = _canonical_schedule_value(declared.get("schedule_type", ""), declared.get("schedule_value", ""))
     if existing_value != declared_value:
         return False
+    if bool(existing.get("run_at_load")) != bool(declared.get("run_on_boot")):
+        return False
     return True
 
 

package/src/scripts/nexo-catchup.py

@@ -123,17 +123,22 @@ def _acquire_lock():
 def run_task(candidate: dict, state: dict) -> bool:
     """Execute a task and update state."""
     name = candidate["cron_id"]
-    script_name = Path(candidate["script"]).name
-    script_path = str(SCRIPTS / script_name)
-    if not Path(script_path).exists():
+    raw_script = str(candidate.get("script", ""))
+    script_candidate = Path(raw_script)
+    if script_candidate.is_absolute():
+        script_path = script_candidate
+    else:
+        script_path = SCRIPTS / script_candidate.name
+    script_name = script_path.name
+    if not script_path.exists():
         log(f"  SKIP {name}: script not found ({script_path})")
         return False
 
     runtime_cmd = _resolve_runtime_command(candidate.get("type", "python"))
     if WRAPPER.exists():
-        command = ["/bin/bash", str(WRAPPER), name, runtime_cmd, script_path]
+        command = ["/bin/bash", str(WRAPPER), name, runtime_cmd, str(script_path)]
     else:
-        command = [runtime_cmd, script_path]
+        command = [runtime_cmd, str(script_path)]
 
     log(f"  RUNNING {name}: {script_name}")
     try:

package/src/server.py

@@ -124,12 +124,16 @@ def _server_init():
 
     # ── Auto-update check (non-blocking, max 5s) ──────────────────
     try:
-        from auto_update import auto_update_check
+        from auto_update import startup_preflight
         import threading
 
         def _bg_update():
             try:
-                result = auto_update_check()
+                result = startup_preflight(entrypoint="server", interactive=False)
+                if result.get("updated"):
+                    print("[NEXO] Startup update applied.", file=sys.stderr)
+                if result.get("deferred_reason"):
+                    print(f"[NEXO] Startup update deferred: {result['deferred_reason']}", file=sys.stderr)
                 if result.get("git_update"):
                     print(f"[NEXO] {result['git_update']}", file=sys.stderr)
                 if result.get("npm_notice"):