nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/mounter.py

@@ -1,210 +0,0 @@
-"""
-Recursive Mounter Prototype (AG-021).
-Enables Nucleus to act as a Host-Runtime for external MCP servers.
-Supported Transports: stdio (MVP).
-"""
-
-import asyncio
-import json
-import logging
-import uuid
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-
-logger = logging.getLogger("MOUNTER")
-
-
-class MountedServer:
-    def __init__(self, name: str, command: str, args: List[str]):
-        self.name = name
-        self.command = command
-        self.args = args
-        self.process: Optional[asyncio.subprocess.Process] = None
-        self.id = f"mnt-{uuid.uuid4().hex[:6]}"
-        self.mounted_at = asyncio.get_event_loop().time()
-        self.tools: List[Dict] = []
-
-    async def start(self):
-        """Starts the external MCP server via stdio."""
-        logger.info(f"🚀 Starting Mounted Server: {self.name} ({self.command} {' '.join(self.args)})")
-        self.process = await asyncio.create_subprocess_exec(
-            self.command, *self.args,
-            stdin=asyncio.subprocess.PIPE,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        # In a real implementation, we would now negotiate list_tools
-        # For the prototype, we assume it's running.
-        return True
-
-    async def stop(self):
-        if self.process:
-            self.process.terminate()
-            await self.process.wait()
-            logger.info(f"🛑 Stopped Mounted Server: {self.name}")
-
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict:
-        """Proxies a tool call to the mounted server via MCP (stdio)."""
-        if not self.process:
-            raise RuntimeError(f"Server {self.name} is not running")
-
-        request = {
-            "jsonrpc": "2.0",
-            "method": "tools/call",
-            "params": {
-                "name": tool_name,
-                "arguments": arguments
-            },
-            "id": str(uuid.uuid4())
-        }
-
-        # Send request
-        self.process.stdin.write((json.dumps(request) + "\n").encode())
-        await self.process.stdin.drain()
-
-        # Read response (one line)
-        line = await self.process.stdout.readline()
-        if not line:
-            return {"success": False, "error": "No response from mounted server"}
-        
-        return json.loads(line.decode())
-
-    async def list_tools(self) -> List[Dict]:
-        """Discover tools from the mounted server via MCP protocol."""
-        if not self.process:
-            return []
-
-        request = {
-            "jsonrpc": "2.0",
-            "method": "tools/list",
-            "params": {},
-            "id": str(uuid.uuid4())
-        }
-
-        try:
-            self.process.stdin.write((json.dumps(request) + "\n").encode())
-            await self.process.stdin.drain()
-
-            # Read response with timeout
-            line = await asyncio.wait_for(
-                self.process.stdout.readline(),
-                timeout=5.0
-            )
-            if not line:
-                return []
-            
-            response = json.loads(line.decode())
-            if "result" in response and "tools" in response["result"]:
-                self.tools = response["result"]["tools"]
-                return self.tools
-            return []
-        except asyncio.TimeoutError:
-            logger.warning(f"Timeout discovering tools from {self.name}")
-            return []
-        except Exception as e:
-            logger.error(f"Error discovering tools from {self.name}: {e}")
-            return []
-
-
-
-class RecursiveMounter:
-    def __init__(self, brain_path: Path):
-        self.brain_path = brain_path
-        self.mounted_servers: Dict[str, MountedServer] = {}
-        self.mounts_file = brain_path / "ledger" / "mounts.json"
-        self.mounts_file.parent.mkdir(parents=True, exist_ok=True)
-        self._load_mounts()
-
-    def _load_mounts(self):
-        """Load persistent mounts from disk."""
-        if not self.mounts_file.exists():
-            return
-            
-        try:
-            data = json.loads(self.mounts_file.read_text())
-            for mount_data in data:
-                # We don't auto-start on load in this MVP, but we restore the config
-                # In a real OS, we would have a startup supervisor.
-                # For now, we just track them.
-                server = MountedServer(
-                    name=mount_data["name"],
-                    command=mount_data["command"],
-                    args=mount_data["args"]
-                )
-                server.id = mount_data["id"]
-                self.mounted_servers[server.id] = server
-        except Exception as e:
-            logger.error(f"Failed to load mounts: {e}")
-
-    def _save_mounts(self):
-        """Save persistent mounts to disk."""
-        data = [
-            {
-                "id": s.id,
-                "name": s.name,
-                "command": s.command,
-                "args": s.args
-            }
-            for s in self.mounted_servers.values()
-        ]
-        self.mounts_file.write_text(json.dumps(data, indent=2))
-
-    async def mount(self, name: str, command: str, args: List[str]) -> str:
-        """Mounts an external MCP server."""
-        # Check for existing name
-        if not name or len(name.strip()) < 2:
-            return "Error: Server name must be at least 2 characters"
-
-        # V9.1 Security: Recursive Self-Mount Detection
-        # Check if the command or args try to launch the nucleus server itself
-        forbidden_patterns = ["mcp_server_nucleus", "mcp-server-nucleus"]
-        cmd_str = f"{command} {' '.join(args)}".lower()
-        for pattern in forbidden_patterns:
-            if pattern in cmd_str:
-                import sys
-                print("[NUCLEUS] SECURITY VIOLATION: Recursive mount detected", file=sys.stderr)
-                return f"Error: Recursive mounting of {pattern} is forbidden for stability."
-
-        for s in self.mounted_servers.values():
-            if s.name == name:
-                 return f"Server {name} is already mounted as {s.id}"
-        
-        server = MountedServer(name, command, args)
-        try:
-            await server.start()
-            self.mounted_servers[server.id] = server
-            self._save_mounts()
-            return f"Successfully mounted {name} as {server.id}"
-        except Exception as e:
-            return f"Failed to mount {name}: {e}"
-
-    async def unmount(self, server_id: str) -> str:
-        """Unmounts and stops a server."""
-        if server_id not in self.mounted_servers:
-            return f"Server {server_id} not found"
-            
-        server = self.mounted_servers[server_id]
-        await server.stop()
-        del self.mounted_servers[server_id]
-        self._save_mounts()
-        return f"Unmounted {server.name} ({server_id})"
-
-    def list_mounted(self) -> List[Dict]:
-        return [
-            {
-                "id": s.id,
-                "name": s.name,
-                "command": s.command,
-                "status": "Running" if s.process and s.process.returncode is None else "Stopped"
-            }
-            for s in self.mounted_servers.values()
-        ]
-
-# Global singleton for prototype
-_mounter: Optional[RecursiveMounter] = None
-
-def get_mounter(brain_path: Path) -> RecursiveMounter:
-    global _mounter
-    if _mounter is None:
-        _mounter = RecursiveMounter(brain_path)
-    return _mounter

package/src/mcp_server_nucleus/runtime/mounter_ops.py

@@ -1,250 +0,0 @@
-
-import json
-import os
-import logging
-from typing import Dict, List, Any
-from pathlib import Path
-
-# Try importing mcp, handle failure gracefully for the "no dependency" case
-try:
-    from mcp import ClientSession, StdioServerParameters
-    from mcp.client.stdio import stdio_client
-    from mcp.client.sse import sse_client
-    MCP_AVAILABLE = True
-except ImportError:
-    MCP_AVAILABLE = False
-    # Mock classes for type hinting if missing
-    ClientSession = Any
-    StdioServerParameters = Any
-
-logger = logging.getLogger("nucleus_mounter")
-
-class Mounter:
-    """
-    Manages connections to external MCP servers (Recursive Mounting).
-    Supports Stdio and SSE transports.
-    """
-    def __init__(self, brain_path: Path):
-        self.brain_path = brain_path
-        self.mounts_file = brain_path / "mounts.json"
-        
-        # In-memory session store: mount_id -> ClientSession
-        self.sessions: Dict[str, ClientSession] = {}
-        # Keep track of exit stack context managers to close them later
-        self.exit_stacks: Dict[str, Any] = {}
-        
-        self.mount_configs: Dict[str, Dict] = {}
-        self._load_mounts()
-
-    def _load_mounts(self):
-        """Load persisted mount configurations."""
-        if self.mounts_file.exists():
-            try:
-                with open(self.mounts_file, "r") as f:
-                    self.mount_configs = json.load(f)
-            except Exception as e:
-                logger.error(f"Failed to load mounts: {e}")
-    async def restore_mounts(self):
-        """Re-establish connections for all persisted mounts."""
-        print(f"🔄 Restoring {len(self.mount_configs)} mounts...")
-        for mount_id, config in self.mount_configs.items():
-            try:
-                if config.get("transport") == "stdio":
-                    await self.mount_server(
-                        mount_id=mount_id,
-                        transport="stdio",
-                        command=config.get("command"),
-                        args=config.get("args"),
-                        env=config.get("env")
-                    )
-                    print(f"  ✅ Re-mounted: {mount_id}")
-                elif config.get("transport") == "sse":
-                    await self.mount_server(
-                        mount_id=mount_id,
-                        transport="sse",
-                        url=config.get("url")
-                    )
-                    print(f"  ✅ Re-mounted: {mount_id}")
-            except Exception as e:
-                logger.error(f"Failed to restore mount {mount_id}: {e}")
-                print(f"  ❌ Failed to restore {mount_id}: {e}")
-    def _save_mounts(self):
-        """Persist mount configurations."""
-        try:
-            with open(self.mounts_file, "w") as f:
-                json.dump(self.mount_configs, f, indent=2)
-        except Exception as e:
-            logger.error(f"Failed to save mounts: {e}")
-
-    async def mount_server(self, 
-                          mount_id: str, 
-                          transport: str, 
-                          command: str = None, 
-                          args: List[str] = None, 
-                          env: Dict[str, str] = None,
-                          url: str = None) -> Dict[str, Any]:
-        """
-        Mount an MCP server.
-        
-        Args:
-            mount_id: Unique identifier for this mount.
-            transport: "stdio" or "sse".
-            command: (stdio) Executable command.
-            args: (stdio) List of arguments.
-            env: (stdio) Environment variables.
-            url: (sse) Server URL.
-        """
-        if not MCP_AVAILABLE:
-            raise ImportError("The 'mcp' package is not installed. Please install it to use mounting features.")
-
-        if mount_id in self.sessions:
-            raise ValueError(f"Mount ID '{mount_id}' is already active.")
-
-        if transport == "stdio":
-            if not command:
-                raise ValueError("Command is required for stdio transport")
-            
-            server_params = StdioServerParameters(
-                command=command,
-                args=args or [],
-                env={**os.environ, **(env or {})}
-            )
-            
-            # We need to maintain the context manager lifecycle
-            # This is a bit tricky in an async methods that keeps the session open.
-            # We'll use an AsyncExitStack stored in class state.
-            from contextlib import AsyncExitStack
-            
-            stack = AsyncExitStack()
-            stdio_transport = await stack.enter_async_context(stdio_client(server_params))
-            self.exit_stacks[mount_id] = stack
-            
-            read, write = stdio_transport
-            session = await stack.enter_async_context(ClientSession(read, write))
-            await session.initialize()
-            
-            self.sessions[mount_id] = session
-            
-            # Persist config
-            self.mount_configs[mount_id] = {
-                "transport": "stdio",
-                "command": command,
-                "args": args,
-                "env": env,
-                "status": "connected"
-            }
-            self._save_mounts()
-            
-            return {"mount_id": mount_id, "status": "connected", "tools": len((await session.list_tools()).tools)}
-
-        elif transport == "sse":
-            if not url:
-                raise ValueError("URL is required for SSE transport")
-                
-            from contextlib import AsyncExitStack
-            stack = AsyncExitStack()
-            sse_transport = await stack.enter_async_context(sse_client(url))
-            self.exit_stacks[mount_id] = stack
-            
-            read, write = sse_transport
-            session = await stack.enter_async_context(ClientSession(read, write))
-            await session.initialize()
-            
-            self.sessions[mount_id] = session
-            
-            self.mount_configs[mount_id] = {
-                "transport": "sse",
-                "url": url,
-                "status": "connected"
-            }
-            self._save_mounts()
-            
-            return {"mount_id": mount_id, "status": "connected", "tools": len((await session.list_tools()).tools)}
-            
-        else:
-            raise ValueError(f"Unknown transport: {transport}")
-
-    async def unmount_server(self, mount_id: str):
-        """Unmount a server and close connection."""
-        if mount_id in self.exit_stacks:
-            await self.exit_stacks[mount_id].aclose()
-            del self.exit_stacks[mount_id]
-        
-        if mount_id in self.sessions:
-            del self.sessions[mount_id]
-            
-        if mount_id in self.mount_configs:
-            del self.mount_configs[mount_id]
-            self._save_mounts()
-
-    async def list_mounts(self) -> List[Dict]:
-        """List active mounts."""
-        return [
-            {"id": k, **v} for k, v in self.mount_configs.items()
-        ]
-
-    async def list_tools(self) -> List[Dict]:
-        """
-        Aggregate tools from all mounted servers.
-        Tools are namespaced as 'mount_id:tool_name'.
-        """
-        aggregated_tools = []
-        
-        for mount_id, session in self.sessions.items():
-            try:
-                result = await session.list_tools()
-                for tool in result.tools:
-                    # Create a namespaced copy of the tool definition
-                    tool_dict = tool.model_dump() if hasattr(tool, "model_dump") else tool.__dict__
-                    tool_dict["name"] = f"{mount_id}:{tool.name}"
-                    tool_dict["description"] = f"[{mount_id}] {tool_dict.get('description', '')}"
-                    aggregated_tools.append(tool_dict)
-            except Exception as e:
-                logger.error(f"Error listing tools for {mount_id}: {e}")
-                
-        return aggregated_tools
-
-    async def call_tool(self, name: str, args: Dict) -> Any:
-        """
-        Call a namespaced tool.
-        Name format: 'mount_id:tool_name'
-        """
-        if ":" not in name:
-            raise ValueError("Invalid namespaced tool name. Format must be 'mount_id:tool_name'")
-            
-        mount_id, tool_name = name.split(":", 1)
-        
-        if mount_id not in self.sessions:
-            raise ValueError(f"Mount ID '{mount_id}' not found")
-            
-        session = self.sessions[mount_id]
-        result = await session.call_tool(tool_name, arguments=args)
-        return result
-
-    async def traverse_and_mount(self, root_mount_id: str) -> Dict:
-        """
-        Recursive discovery logic.
-        Inspects tools of a mounted server to find other 'mount_server' compatible capabilities.
-        This is a heuristic implementation for the demo.
-        """
-        if root_mount_id not in self.sessions:
-             raise ValueError(f"Root mount '{root_mount_id}' not found")
-
-        session = self.sessions[root_mount_id]
-        tools = await session.list_tools()
-        
-        found_servers = []
-        
-        # Heuristic: Look for tools that return 'mcp_server' or have 'mount' in description
-        # In a real scenario, this would use a standardized 'list_servers' tool or resource.
-        # For the demo, we'll just report what we see.
-        
-        for tool in tools.tools:
-             if "server" in tool.name.lower() or "mount" in tool.name.lower():
-                 found_servers.append(tool.name)
-                 
-        return {
-            "root": root_mount_id,
-            "potential_sub_servers": found_servers,
-            "status": "traversal_complete"
-        }

package/src/mcp_server_nucleus/runtime/nuke_protocol.py

@@ -1,147 +0,0 @@
-"""
-The .nuke Protocol (Nucleus Universal Knowledge Exchange).
-Phase 57 Implementation.
-
-Format: ZIP Archive
-Structure:
-  /manifest.json (AgentManifest Schema)
-  /signature.sig (Ed25519 Signature of manifest.json)
-  /tools/ (Python Code)
-"""
-
-import json
-import logging
-import zipfile
-import shutil
-import tempfile
-from pathlib import Path
-from typing import List, Dict
-
-from .identity.keygen import KeyManager
-from .identity.manifest import AgentManifest, ManifestValidator
-
-logger = logging.getLogger("NUKE_PROTOCOL")
-
-class NukePacker:
-    """
-    Creates signed .nuke artifacts.
-    """
-    def __init__(self, staging_root: Path):
-        self.staging_root = staging_root
-        self.staging_root.mkdir(parents=True, exist_ok=True)
-        self.key_manager = KeyManager()
-
-    def pack(self, manifest: AgentManifest, tool_paths: List[Path], private_key_pem: str, output_path: Path) -> Path:
-        """
-        Bundles an agent into a .nuke file.
-        """
-        logger.info(f"📦 Packing Agent: {manifest.agent.id} -> {output_path}")
-        
-        # 1. Create Staging Area
-        with tempfile.TemporaryDirectory(dir=self.staging_root) as tmp_dir:
-            staging_dir = Path(tmp_dir)
-            tools_dir = staging_dir / "tools"
-            tools_dir.mkdir()
-            
-            # 2. Add Tools
-            for tool_path in tool_paths:
-                if not tool_path.exists():
-                    raise FileNotFoundError(f"Tool not found: {tool_path}")
-                shutil.copy2(tool_path, tools_dir / tool_path.name)
-                
-            # 3. Write Manifest
-            manifest_json = manifest.model_dump_json(indent=2)
-            manifest_path = staging_dir / "manifest.json"
-            manifest_path.write_text(manifest_json)
-            
-            # 4. Sign Manifest
-            # We sign the BYTES of the manifest.json file to ensure exact integrity
-            manifest_bytes = manifest_path.read_bytes()
-            signature = self.key_manager.sign(private_key_pem, manifest_bytes)
-            
-            # Save signature as hex string
-            (staging_dir / "signature.sig").write_text(signature.hex())
-            
-            # 5. Zip it
-            with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zf:
-                for file in staging_dir.rglob("*"):
-                    if file.is_file():
-                        zf.write(file, file.relative_to(staging_dir))
-                        
-        logger.info(f"✅ Created {output_path} ({output_path.stat().st_size} bytes)")
-        return output_path
-
-class NukeLoader:
-    """
-    Loads and Verifies .nuke artifacts.
-    """
-    def __init__(self, install_root: Path):
-        self.install_root = install_root
-        self.key_manager = KeyManager()
-        self.installed_tools_dir = install_root / "tools" / "installed"
-        self.installed_tools_dir.mkdir(parents=True, exist_ok=True)
-
-    def load(self, nuke_path: Path, trusted_keys: Dict[str, str]) -> AgentManifest:
-        """
-        Verifies and Unpacks a .nuke file.
-        trusted_keys: Dict[KeyID, PublicKeyPEM]
-        """
-        logger.info(f"🔓 Loading .nuke: {nuke_path}")
-        
-        with zipfile.ZipFile(nuke_path, 'r') as zf:
-            # 1. Extract Manifest & Sig to memory
-            try:
-                manifest_bytes = zf.read("manifest.json")
-                signature_hex = zf.read("signature.sig").decode().strip()
-                signature_bytes = bytes.fromhex(signature_hex)
-            except KeyError:
-                raise ValueError("❌ Invalid .nuke: Missing manifest or signature")
-                
-            # 2. Parse Manifest
-            try:
-                manifest_dict = json.loads(manifest_bytes)
-                manifest = ManifestValidator.validate(manifest_dict)
-            except Exception as e:
-                raise ValueError(f"❌ Invalid Manifest: {e}")
-                
-            # 3. Lookup Public Key
-            # In Phase 57, we assume the publisher ID is embedded in the manifest or we trust the signer
-            # For this MVP, we verify using the TRUSTED_KEYS passed in.
-            # We treat the Key ID as the signer.
-            
-            # Note: The Manifest doesn't strictly have a "signer_id" field in our schema yet.
-            # We rely on the KeyManager logic: We need the Public Key corresponding to the Private Key that signed it.
-            # In a real PKI, the Manifest would contain the KeyID, or the Repository would provide it.
-            # Let's try every trusted key. If ANY valid key verifies it, we are good.
-            
-            verified = False
-            signer_key_id = None
-            
-            for key_id, pub_pem in trusted_keys.items():
-                if self.key_manager.verify(pub_pem, signature_bytes, manifest_bytes):
-                    verified = True
-                    signer_key_id = key_id
-                    break
-                    
-            if not verified:
-                raise PermissionError("❌ SIGNATURE VERIFICATION FAILED: No trusted key matches signature")
-                
-            logger.info(f"✅ Verified by KeyID: {signer_key_id}")
-            
-            # 4. Install Tools
-            # We namespace them by Agent ID to avoid collisions
-            agent_dir = self.installed_tools_dir / manifest.agent.id
-            if agent_dir.exists():
-                shutil.rmtree(agent_dir)
-            agent_dir.mkdir()
-            
-            for file in zf.namelist():
-                if file.startswith("tools/") and file.endswith(".py"):
-                    # Extract tool code
-                    tool_content = zf.read(file)
-                    tool_name = Path(file).name
-                    (agent_dir / tool_name).write_bytes(tool_content)
-                    
-            logger.info(f"    -> Installed {len(list(agent_dir.glob('*.py')))} tools to {agent_dir}")
-            
-            return manifest