nexo-brain 5.3.13 → 5.3.15

package/src/plugin_loader 2.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+"""Dynamic plugin loader for NEXO MCP server."""
+
+import importlib
+import importlib.util
+import os
+import signal
+import sys
+import time
+
+from db import get_db
+from fastmcp.tools import Tool
+
+SERVER_DIR = os.path.dirname(os.path.abspath(__file__))
+PLUGINS_DIR = os.path.join(SERVER_DIR, "plugins")
+
+# Personal plugins directory: NEXO_HOME/plugins/ (env var, defaults to ~/.nexo/)
+NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+PERSONAL_PLUGINS_DIR = os.path.join(NEXO_HOME, "plugins")
+
+PLUGIN_LOAD_TIMEOUT = 10  # seconds per plugin
+
+
+class _PluginTimeout(Exception):
+    pass
+
+
+def _timeout_handler(signum, frame):
+    raise _PluginTimeout("Plugin loading timed out")
+
+
+def _ensure_src_in_path():
+    """Ensure server src/ is in sys.path so personal plugins can import db, cognitive, etc."""
+    if SERVER_DIR not in sys.path:
+        sys.path.insert(0, SERVER_DIR)
+
+
+def load_all_plugins(mcp) -> int:
+    """Load all plugins from repo and personal directories at startup. Returns total tools loaded."""
+    _ensure_src_in_path()
+    total = 0
+
+    # Collect plugins: repo first, personal overrides
+    plugin_map = {}  # filename -> (dir_path, source_label)
+
+    # 1. Repo plugins (base)
+    if os.path.isdir(PLUGINS_DIR):
+        for f in sorted(os.listdir(PLUGINS_DIR)):
+            if f.endswith(".py") and f != "__init__.py":
+                plugin_map[f] = (PLUGINS_DIR, "repo")
+
+    # 2. Personal plugins (override if same filename)
+    if os.path.isdir(PERSONAL_PLUGINS_DIR):
+        for f in sorted(os.listdir(PERSONAL_PLUGINS_DIR)):
+            if f.endswith(".py") and f != "__init__.py":
+                source = "personal (override)" if f in plugin_map else "personal"
+                plugin_map[f] = (PERSONAL_PLUGINS_DIR, source)
+
+    # Load all in sorted order
+    for f in sorted(plugin_map):
+        plugins_dir, source_label = plugin_map[f]
+        try:
+            old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
+            signal.alarm(PLUGIN_LOAD_TIMEOUT)
+            try:
+                n = load_plugin(mcp, f, plugins_dir=plugins_dir)
+                total += n
+                print(f"[PLUGIN LOADED] {f} ({n} tools) from {source_label}: {plugins_dir}", file=sys.stderr)
+            finally:
+                signal.alarm(0)
+                signal.signal(signal.SIGALRM, old_handler)
+        except _PluginTimeout:
+            print(f"[PLUGIN TIMEOUT] {f}: skipped after {PLUGIN_LOAD_TIMEOUT}s", file=sys.stderr)
+        except Exception as e:
+            print(f"[PLUGIN ERROR] {f}: {e}", file=sys.stderr)
+    return total
+
+
+def load_plugin(mcp, filename: str, plugins_dir: str | None = None) -> int:
+    """Load or reload a single plugin. Returns number of tools registered.
+
+    Args:
+        plugins_dir: Directory to load from. If None, searches repo PLUGINS_DIR first,
+                     then PERSONAL_PLUGINS_DIR. Personal plugins are loaded via
+                     importlib.util.spec_from_file_location.
+    """
+    if not filename.endswith(".py"):
+        filename += ".py"
+
+    # Reject path separators and traversal sequences before joining
+    if "/" in filename or "\\" in filename or ".." in filename:
+        raise ValueError(f"Invalid plugin filename (path separators or '..' not allowed): {filename}")
+
+    if plugins_dir is not None:
+        filepath = os.path.join(plugins_dir, filename)
+        if not os.path.isfile(filepath):
+            raise FileNotFoundError(f"Plugin not found: {filepath}")
+    else:
+        # Search repo first, then personal
+        repo_path = os.path.join(PLUGINS_DIR, filename)
+        personal_path = os.path.join(PERSONAL_PLUGINS_DIR, filename)
+        if os.path.isfile(repo_path):
+            plugins_dir = PLUGINS_DIR
+            filepath = repo_path
+        elif os.path.isfile(personal_path):
+            plugins_dir = PERSONAL_PLUGINS_DIR
+            filepath = personal_path
+        else:
+            raise FileNotFoundError(
+                f"Plugin not found in repo ({PLUGINS_DIR}) or personal ({PERSONAL_PLUGINS_DIR}): {filename}"
+            )
+
+    # Security: reject path traversal — resolved path must stay inside allowed directories
+    real_path = os.path.realpath(filepath)
+    real_plugins = os.path.realpath(PLUGINS_DIR)
+    real_personal = os.path.realpath(PERSONAL_PLUGINS_DIR)
+    if not (real_path.startswith(real_plugins + os.sep) or real_path.startswith(real_personal + os.sep)):
+        raise ValueError(
+            f"Path traversal blocked: {filename!r} resolves to {real_path}, "
+            f"which is outside {real_plugins} and {real_personal}"
+        )
+
+    module_name = f"plugins.{filename[:-3]}"
+
+    # For personal plugins (outside repo), use spec_from_file_location
+    if plugins_dir != PLUGINS_DIR:
+        _ensure_src_in_path()
+        spec = importlib.util.spec_from_file_location(module_name, filepath)
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Cannot create module spec for {filepath}")
+        mod = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = mod
+        spec.loader.exec_module(mod)
+    elif module_name in sys.modules:
+        mod = importlib.reload(sys.modules[module_name])
+    else:
+        mod = importlib.import_module(module_name)
+
+    tools_list = getattr(mod, "TOOLS", [])
+    tool_names = []
+
+    for func, name, description in tools_list:
+        try:
+            mcp.local_provider.remove_tool(name)
+        except Exception:
+            pass
+        t = Tool.from_function(func, name=name, description=description)
+        mcp.add_tool(t)
+        tool_names.append(name)
+
+    source_label = "personal" if plugins_dir != PLUGINS_DIR else "repo"
+    _update_registry(filename, len(tool_names), ",".join(tool_names), source_label)
+
+    return len(tool_names)
+
+
+def remove_plugin(mcp, filename: str) -> list[str]:
+    """Unregister a plugin's tools from MCP and clean the registry.
+
+    Does NOT delete plugin files — only unregisters tools to avoid
+    accidental deletion of code from repo or personal directories.
+    """
+    if not filename.endswith(".py"):
+        filename += ".py"
+
+    conn = get_db()
+    row = conn.execute("SELECT tool_names FROM plugins WHERE filename = ?", (filename,)).fetchone()
+
+    removed = []
+    if row and row["tool_names"]:
+        for name in row["tool_names"].split(","):
+            name = name.strip()
+            if name:
+                try:
+                    mcp.local_provider.remove_tool(name)
+                    removed.append(name)
+                except Exception:
+                    pass
+
+    module_name = f"plugins.{filename[:-3]}"
+    sys.modules.pop(module_name, None)
+
+    conn = get_db()
+    conn.execute("DELETE FROM plugins WHERE filename = ?", (filename,))
+    conn.commit()
+
+    return removed
+
+
+def list_plugins() -> list[dict]:
+    """List all registered plugins with source info (repo/personal)."""
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT filename, tools_count, tool_names, loaded_at, created_by FROM plugins ORDER BY filename"
+    ).fetchall()
+    result = []
+    for r in rows:
+        d = dict(r)
+        d["source"] = d.get("created_by", "repo")
+        result.append(d)
+    return result
+
+
+def _update_registry(filename: str, tools_count: int, tool_names: str, created_by: str):
+    """Insert or update plugin registry entry. Non-fatal on lock — tools still work."""
+    now = time.time()
+    try:
+        conn = get_db()
+        conn.execute(
+            "INSERT INTO plugins (filename, tools_count, tool_names, loaded_at, created_by) "
+            "VALUES (?, ?, ?, ?, ?) "
+            "ON CONFLICT(filename) DO UPDATE SET tools_count=?, tool_names=?, loaded_at=?, created_by=?",
+            (filename, tools_count, tool_names, now, created_by, tools_count, tool_names, now, created_by),
+        )
+        conn.commit()
+    except Exception as e:
+        print(f"[PLUGIN REGISTRY] Skipped update for {filename}: {e}")

package/src/plugins/agents.py

@@ -1,6 +1,12 @@
 """Agents plugin — registry of known agent types with their configs."""
 from db import create_agent, get_agent, list_agents, update_agent, delete_agent
 
+try:
+    from client_preferences import resolve_user_model
+    _DEFAULT_AGENT_MODEL = resolve_user_model()
+except Exception:
+    _DEFAULT_AGENT_MODEL = ""
+
 def handle_agent_get(id: str) -> str:
     """Get an agent's full profile by ID."""
     a = get_agent(id)
@@ -11,11 +17,12 @@ def handle_agent_get(id: str) -> str:
     if a["rules"]: lines.append(f"  Reglas: {a['rules']}")
     return "\n".join(lines)
 
-def handle_agent_create(id: str, name: str, specialization: str, model: str = "sonnet",
+def handle_agent_create(id: str, name: str, specialization: str, model: str = "",
                         tools: str = "", context_files: str = "", rules: str = "") -> str:
     """Register a new agent in the registry."""
-    create_agent(id, name, specialization, model, tools, context_files, rules)
-    return f"Agent '{id}' ({name}) registered. Model: {model}"
+    effective_model = model or _DEFAULT_AGENT_MODEL
+    create_agent(id, name, specialization, effective_model, tools, context_files, rules)
+    return f"Agent '{id}' ({name}) registered. Model: {effective_model}"
 
 def handle_agent_update(id: str, name: str = "", specialization: str = "", model: str = "",
                         tools: str = "", context_files: str = "", rules: str = "") -> str: