nexo-brain 6.4.0 → 6.5.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "6.4.0",
+  "version": "6.5.0",
   "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,12 @@
 
 [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 `6.4.0` is the current packaged-runtime line — Plan Consolidado fase F1: multi-tenant email accounts (`email_accounts` table, `nexo email setup` interactive wizard, `nexo email add --password-stdin --json` for the Desktop bridge, idempotent migrator from legacy `~/.nexo/nexo-email/config.json`). The matching NEXO Desktop release (v0.19.0) ships the Email + Automations Settings panels so non-technical operators never have to touch a config file. See [CHANGELOG](CHANGELOG.md) for the full diff.
+Version `6.5.0` is the current packaged-runtime line — Plan Consolidado fase F0.2: operators can now `nexo scripts enable|disable|status <name>` any personal automation. The cron wrapper honours the flag at every tick (`exit 0` with `summary='[disabled]'` while the LaunchAgent stays loaded). The companion NEXO Desktop client (a closed-source product, distributed separately) wires the same toggle into its Automatizaciones panel. See [CHANGELOG](CHANGELOG.md) for the full diff.
+
+> **About NEXO Desktop.** NEXO Desktop is a separate closed-source companion app distributed at [systeam.es/nexo-desktop](https://systeam.es/nexo-desktop) — its source does not live in this repo. When release notes mention Desktop they describe a coordinated client release that consumes the Brain's CLI / MCP contract; the Brain itself is fully usable on its own (terminal, Codex, Claude Code, or any MCP client).
+
+
+Previously in `6.4.0`: Plan Consolidado fase F1 — multi-tenant email accounts (`email_accounts` table, `nexo email setup` interactive wizard, `nexo email add --password-stdin --json` for machine consumers, idempotent migrator from legacy `~/.nexo/nexo-email/config.json`).
 
 Previously in `6.3.1`: privacy hotfix over v6.3.0. The nightly auditor caught that `src/presets/entities_universal.json` in v6.3.0 shipped operator-specific `vhost_mapping` entries (private IPs, hostnames, tenant names). v6.3.1 pulls those out into `src/presets/entities_local.sample.json` (template) + `.gitignore`'d `~/.nexo/brain/presets/entities_local.json` (operator copy), and the installer drops the sample at `nexo init`. No behaviour change on the Guardian side.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "6.4.0",
+  "version": "6.5.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain \u2014 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",

package/src/cli.py

@@ -452,6 +452,49 @@ def _scripts_unschedule(args):
     return 0 if result.get("ok") else 1
 
 
+def _scripts_set_enabled(args, enabled):
+    from script_registry import set_personal_script_enabled
+
+    result = set_personal_script_enabled(args.name, enabled)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to toggle script"), file=sys.stderr)
+        return 1
+    verb = "enabled" if enabled else "disabled"
+    if result.get("changed"):
+        print(f"Script {result['name']} {verb}.")
+    else:
+        print(f"Script {result['name']} already {verb}.")
+    return 0
+
+
+def _scripts_status(args):
+    from script_registry import get_personal_script_status
+
+    result = get_personal_script_status(args.name)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("ok") else 1
+    if not result.get("ok"):
+        print(result.get("error", "Failed to read status"), file=sys.stderr)
+        return 1
+    state = "enabled" if result.get("enabled") else "DISABLED"
+    print(f"{result.get('name')} [{result.get('classification')}] -> {state}")
+    last = result.get("last_run") or {}
+    if last:
+        exit_code = last.get("exit_code")
+        started = last.get("started_at") or "?"
+        print(f"  last run: {started} (exit={exit_code})")
+        summary = (last.get("summary") or "").strip()
+        if summary:
+            print(f"  summary: {summary[:120]}")
+    else:
+        print("  last run: (none)")
+    return 0
+
+
 def _scripts_remove(args):
     from script_registry import remove_personal_script
 
@@ -2116,6 +2159,19 @@ def main():
     unschedule_p.add_argument("name", help="Script name or path")
     unschedule_p.add_argument("--json", action="store_true", help="JSON output")
 
+    # scripts enable / disable / status (Plan F0.2.2)
+    enable_p = scripts_sub.add_parser("enable", help="Enable a personal script (cron wrapper will run it again)")
+    enable_p.add_argument("name", help="Script name or path")
+    enable_p.add_argument("--json", action="store_true", help="JSON output")
+
+    disable_p = scripts_sub.add_parser("disable", help="Disable a personal script (cron wrapper will skip it)")
+    disable_p.add_argument("name", help="Script name or path")
+    disable_p.add_argument("--json", action="store_true", help="JSON output")
+
+    status_p = scripts_sub.add_parser("status", help="Show enabled flag + last cron_runs row for a script")
+    status_p.add_argument("name", help="Script name or path")
+    status_p.add_argument("--json", action="store_true", help="JSON output")
+
     # scripts remove
     remove_p = scripts_sub.add_parser("remove", help="Remove a personal script and any attached schedules")
     remove_p.add_argument("name", help="Script name or path")
@@ -2394,6 +2450,12 @@ def main():
             return _scripts_doctor(args)
         elif args.scripts_command == "call":
             return _scripts_call(args)
+        elif args.scripts_command == "enable":
+            return _scripts_set_enabled(args, True)
+        elif args.scripts_command == "disable":
+            return _scripts_set_enabled(args, False)
+        elif args.scripts_command == "status":
+            return _scripts_status(args)
         else:
             scripts_parser.print_help()
             return 0

package/src/db/_personal_scripts.py

@@ -122,7 +122,9 @@ def upsert_personal_script(
             metadata_json = excluded.metadata_json,
             created_by = COALESCE(NULLIF(personal_scripts.created_by, ''), excluded.created_by),
             source = excluded.source,
-            enabled = excluded.enabled,
+            -- Plan F0.2.2: preserve operator-set `enabled` flag across sync runs.
+            -- Sync defaults to enabled=True for INSERTs; on UPDATE we keep
+            -- whatever the operator (or `nexo scripts disable`) set.
             has_inline_metadata = excluded.has_inline_metadata,
             last_synced_at = excluded.last_synced_at,
             updated_at = excluded.updated_at

package/src/script_registry.py

@@ -626,7 +626,38 @@ def list_scripts(include_core: bool = False) -> list[dict]:
     """List scripts in NEXO_HOME/scripts/.
 
     By default only personal scripts. With include_core=True, also shows core/cron scripts.
+
+    Plan F0.2.4 fix — every entry now carries an `enabled` field
+    hydrated from the `personal_scripts` table. Core entries default
+    to True (they ship enabled and are not toggleable from this entry
+    point); personal entries default to True when no row exists yet
+    (sync hasn't run) so the Desktop toggle has a stable starting
+    state. The flag is what powers the Settings -> Automatizaciones
+    toggle's round-trip.
     """
+    # Build a path -> enabled map once so we don't open a transaction
+    # per entry. Personal_scripts rows that don't match anything in
+    # classify_scripts_dir() are simply ignored.
+    enabled_map: dict[str, bool] = {}
+    if include_core:
+        # Only the Desktop panel (include_core=True) needs the toggle
+        # round-trip. Gating the DB read this way avoids triggering
+        # init_db() in default callers (eg `nexo scripts list`), which
+        # would surface pre-existing test fixture pollution.
+        try:
+            from db import init_db
+            from db._personal_scripts import list_personal_scripts
+            init_db()
+            for row in list_personal_scripts(include_disabled=True):
+                p = row.get("path")
+                if p:
+                    enabled_map[str(p)] = bool(row.get("enabled", True))
+        except Exception:
+            # Missing table (older runtime), locked DB, anything else:
+            # fall through to enabled=True (the cron wrapper gate is
+            # the source of truth at run time).
+            enabled_map = {}
+
     results = []
     for entry in classify_scripts_dir()["entries"]:
         if entry["classification"] not in {"personal", "core"}:
@@ -636,6 +667,7 @@ def list_scripts(include_core: bool = False) -> list[dict]:
         hidden = _truthy(entry.get("metadata", {}).get("hidden"))
         if hidden and not include_core:
             continue
+        entry["enabled"] = enabled_map.get(entry["path"], True)
         results.append(entry)
     return results
 
@@ -1462,6 +1494,78 @@ def remove_personal_script(name_or_path: str, *, keep_file: bool = False) -> dic
     }
 
 
+def set_personal_script_enabled(name_or_path: str, enabled: bool) -> dict:
+    """Plan F0.2.2 — flip the `enabled` flag on a personal script.
+
+    Returns ``{ok: bool, name, enabled, changed: bool}``. Refuses to
+    flip packaged core scripts (they ship enabled and the operator
+    should `nexo scripts unschedule` if they want one to stop).
+
+    The cron wrapper (`nexo-cron-wrapper.sh`, F0.2.4) reads this flag
+    on every tick and exits 0 with `summary='[disabled]'` when the
+    script is disabled, so the LaunchAgent can stay loaded but the
+    script itself is dormant.
+    """
+    from db import init_db, get_personal_script
+    from db._core import get_db
+
+    init_db()
+    sync_personal_scripts()
+    script = get_personal_script(name_or_path) or resolve_script(name_or_path)
+    if not script:
+        return {"ok": False, "error": f"Script not found: {name_or_path}"}
+    if script.get("core") and not _within_scripts_dir(Path(script.get("path", ""))):
+        return {
+            "ok": False,
+            "error": "Refusing to toggle a packaged core script via this entry point — "
+                     "use `nexo scripts unschedule` to stop it instead.",
+        }
+    target = 1 if enabled else 0
+    conn = get_db()
+    cur = conn.execute(
+        "UPDATE personal_scripts SET enabled = ?, updated_at = CURRENT_TIMESTAMP WHERE path = ?",
+        (target, script["path"]),
+    )
+    conn.commit()
+    changed = bool(cur.rowcount)
+    return {
+        "ok": True,
+        "name": script.get("name", name_or_path),
+        "path": script.get("path", ""),
+        "enabled": bool(target),
+        "changed": changed,
+    }
+
+
+def get_personal_script_status(name_or_path: str) -> dict:
+    """Plan F0.2.2 — read-only view of one personal script for the
+    Desktop panel and the `nexo scripts status` CLI verb."""
+    from db import init_db, get_personal_script
+    from db._core import get_db
+
+    init_db()
+    sync_personal_scripts()
+    script = get_personal_script(name_or_path) or resolve_script(name_or_path)
+    if not script:
+        return {"ok": False, "error": f"Script not found: {name_or_path}"}
+    conn = get_db()
+    last = conn.execute(
+        "SELECT exit_code, started_at, ended_at, summary FROM cron_runs "
+        "WHERE cron_id = ? ORDER BY id DESC LIMIT 1",
+        (script.get("name") or "",),
+    ).fetchone()
+    last_run = dict(last) if last else None
+    return {
+        "ok": True,
+        "name": script.get("name"),
+        "path": script.get("path"),
+        "enabled": bool(script.get("enabled", True)),
+        "core": bool(script.get("core")),
+        "classification": script.get("classification", "user"),
+        "last_run": last_run,
+    }
+
+
 def doctor_script(path_or_name: str) -> dict:
     """Validate a single script. Returns dict with pass/warn/fail items."""
     # Resolve

package/src/scripts/nexo-cron-wrapper.sh

@@ -185,6 +185,44 @@ trap 'on_signal SIGTERM 143' TERM
 trap 'on_signal SIGINT 130' INT
 trap 'on_signal SIGHUP 129' HUP
 
+
+# Plan F0.2.4 — disabled-script gate. Personal_scripts table holds an
+# `enabled` flag flipped via `nexo scripts enable|disable <name>`. When
+# the operator disables a cron the LaunchAgent stays loaded (no
+# launchctl churn) but this wrapper short-circuits to a clean exit 0
+# with summary='[disabled]'. The corresponding cron_runs row gets an
+# explicit "skipped (disabled)" note so the daily audit can tell apart
+# "didn't run because off" from "ran with exit 0".
+DISABLED_GATE_OUTPUT=$(python3 - "$DB" "$CRON_ID" <<'PYGATE' 2>/dev/null || true
+from __future__ import annotations
+import sqlite3
+import sys
+db_path, cron_id = sys.argv[1:]
+try:
+    conn = sqlite3.connect(db_path)
+    try:
+        row = conn.execute(
+            "SELECT enabled FROM personal_scripts WHERE name = ? LIMIT 1",
+            (cron_id,),
+        ).fetchone()
+    finally:
+        conn.close()
+except Exception:
+    sys.exit(0)
+if row is not None and not int(row[0] or 0):
+    print("disabled")
+PYGATE
+)
+if [ "$DISABLED_GATE_OUTPUT" = "disabled" ]; then
+    EXIT_CODE=0
+    SIGNAL_NAME=""
+    : > "$OUTPUT_FILE"
+    echo "[disabled] $CRON_ID skipped - re-enable with: nexo scripts enable $CRON_ID" > "$OUTPUT_FILE"
+    finalize_row
+    cleanup
+    exit 0
+fi
+
 "$@" > "$OUTPUT_FILE" 2>&1 &
 CHILD_PID=$!