clonebox 1.1.12__py3-none-any.whl → 1.1.14__py3-none-any.whl

clonebox/plugins/manager.py

@@ -0,0 +1,438 @@
+"""
+Plugin manager for CloneBox.
+Handles plugin discovery, loading, and lifecycle.
+"""
+import importlib
+import importlib.util
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Type, Set
+import threading
+import yaml
+
+from clonebox.plugins.base import Plugin, PluginHook, PluginContext, PluginMetadata
+
+
+@dataclass
+class LoadedPlugin:
+    """Information about a loaded plugin."""
+    plugin: Plugin
+    metadata: PluginMetadata
+    config: Dict[str, Any]
+    enabled: bool = True
+    load_order: int = 0
+
+
+class PluginManager:
+    """
+    Manages CloneBox plugins.
+
+    Plugins can be loaded from:
+    - Built-in plugins (clonebox.plugins.builtin.*)
+    - User plugins (~/.clonebox.d/plugins/)
+    - Project plugins (.clonebox.d/plugins/)
+    - Python packages (clonebox_plugin_*)
+
+    Usage:
+        manager = PluginManager()
+        manager.discover()
+        manager.load_all()
+
+        # Trigger a hook
+        ctx = PluginContext(hook=PluginHook.POST_VM_CREATE, vm_name="my-vm")
+        manager.trigger(PluginHook.POST_VM_CREATE, ctx)
+    """
+
+    DEFAULT_PLUGIN_DIRS = [
+        Path.home() / ".clonebox.d" / "plugins",
+        Path(".clonebox.d") / "plugins",
+    ]
+
+    def __init__(
+        self,
+        plugin_dirs: Optional[List[Path]] = None,
+        config_path: Optional[Path] = None,
+    ):
+        self._plugins: Dict[str, LoadedPlugin] = {}
+        self._hooks: Dict[PluginHook, List[str]] = {hook: [] for hook in PluginHook}
+        self._lock = threading.Lock()
+        self._load_order = 0
+
+        # Plugin directories
+        self.plugin_dirs = plugin_dirs or self.DEFAULT_PLUGIN_DIRS
+
+        # Plugin configuration
+        self.config_path = config_path or Path.home() / ".clonebox.d" / "plugins.yaml"
+        self._plugin_config = self._load_config()
+
+    def _load_config(self) -> Dict[str, Any]:
+        """Load plugin configuration."""
+        if self.config_path.exists():
+            try:
+                with open(self.config_path) as f:
+                    return yaml.safe_load(f) or {}
+            except Exception:
+                return {}
+        return {}
+
+    def _save_config(self) -> None:
+        """Save plugin configuration."""
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_path, "w") as f:
+            yaml.dump(self._plugin_config, f, default_flow_style=False)
+
+    def discover(self) -> List[str]:
+        """
+        Discover available plugins.
+        Returns list of discovered plugin names.
+        """
+        discovered: List[str] = []
+
+        # Discover from plugin directories
+        for plugin_dir in self.plugin_dirs:
+            if plugin_dir.exists() and plugin_dir.is_dir():
+                for item in plugin_dir.iterdir():
+                    if item.is_file() and item.suffix == ".py" and not item.name.startswith("_"):
+                        name = item.stem
+                        discovered.append(f"file:{name}")
+                    elif item.is_dir() and (item / "__init__.py").exists():
+                        discovered.append(f"file:{item.name}")
+
+        # Discover installed packages (clonebox_plugin_*)
+        try:
+            import pkg_resources
+            for ep in pkg_resources.iter_entry_points("clonebox.plugins"):
+                discovered.append(f"pkg:{ep.name}")
+        except ImportError:
+            pass
+
+        return discovered
+
+    def load(self, plugin_name: str, config: Optional[Dict[str, Any]] = None) -> bool:
+        """
+        Load a specific plugin.
+
+        Args:
+            plugin_name: Plugin name (can be prefixed with file: or pkg:)
+            config: Plugin-specific configuration
+
+        Returns:
+            True if loaded successfully
+        """
+        with self._lock:
+            if plugin_name in self._plugins:
+                return True  # Already loaded
+
+            try:
+                plugin_class = self._import_plugin(plugin_name)
+                if plugin_class is None:
+                    return False
+
+                plugin = plugin_class()
+                metadata = plugin.metadata
+
+                # Get config
+                plugin_config = config or self._plugin_config.get(metadata.name, {})
+
+                # Check dependencies
+                for dep in metadata.dependencies:
+                    if dep not in self._plugins:
+                        # Try to load dependency
+                        if not self.load(dep):
+                            raise RuntimeError(f"Missing dependency: {dep}")
+
+                # Initialize plugin
+                plugin.initialize(plugin_config)
+
+                # Register plugin
+                self._load_order += 1
+                loaded = LoadedPlugin(
+                    plugin=plugin,
+                    metadata=metadata,
+                    config=plugin_config,
+                    enabled=True,
+                    load_order=self._load_order,
+                )
+                self._plugins[metadata.name] = loaded
+
+                # Register hooks
+                for hook in metadata.hooks:
+                    self._hooks[hook].append(metadata.name)
+
+                return True
+
+            except Exception as e:
+                import sys
+                print(f"Failed to load plugin {plugin_name}: {e}", file=sys.stderr)
+                return False
+
+    def _import_plugin(self, plugin_name: str) -> Optional[Type[Plugin]]:
+        """Import a plugin class."""
+        if plugin_name.startswith("file:"):
+            return self._import_file_plugin(plugin_name[5:])
+        elif plugin_name.startswith("pkg:"):
+            return self._import_package_plugin(plugin_name[4:])
+        else:
+            # Try both
+            plugin_class = self._import_package_plugin(plugin_name)
+            if plugin_class:
+                return plugin_class
+            return self._import_file_plugin(plugin_name)
+
+    def _import_file_plugin(self, name: str) -> Optional[Type[Plugin]]:
+        """Import plugin from file."""
+        for plugin_dir in self.plugin_dirs:
+            # Try as single file
+            plugin_file = plugin_dir / f"{name}.py"
+            if plugin_file.exists():
+                return self._load_module_from_file(name, plugin_file)
+
+            # Try as package
+            plugin_pkg = plugin_dir / name / "__init__.py"
+            if plugin_pkg.exists():
+                return self._load_module_from_file(name, plugin_pkg)
+
+        return None
+
+    def _load_module_from_file(self, name: str, path: Path) -> Optional[Type[Plugin]]:
+        """Load a module from file and find Plugin class."""
+        try:
+            spec = importlib.util.spec_from_file_location(f"clonebox_plugin_{name}", path)
+            if spec is None or spec.loader is None:
+                return None
+
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[spec.name] = module
+            spec.loader.exec_module(module)
+
+            # Find Plugin subclass
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (
+                    isinstance(attr, type)
+                    and issubclass(attr, Plugin)
+                    and attr is not Plugin
+                ):
+                    return attr
+
+            return None
+
+        except Exception:
+            return None
+
+    def _import_package_plugin(self, name: str) -> Optional[Type[Plugin]]:
+        """Import plugin from installed package."""
+        try:
+            import pkg_resources
+            for ep in pkg_resources.iter_entry_points("clonebox.plugins"):
+                if ep.name == name:
+                    plugin_class = ep.load()
+                    if issubclass(plugin_class, Plugin):
+                        return plugin_class
+        except ImportError:
+            pass
+
+        # Try direct import
+        try:
+            module = importlib.import_module(f"clonebox_plugin_{name}")
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (
+                    isinstance(attr, type)
+                    and issubclass(attr, Plugin)
+                    and attr is not Plugin
+                ):
+                    return attr
+        except ImportError:
+            pass
+
+        return None
+
+    def load_all(self, only_enabled: bool = True) -> int:
+        """
+        Load all discovered plugins.
+
+        Args:
+            only_enabled: Only load plugins marked as enabled in config
+
+        Returns:
+            Number of plugins loaded
+        """
+        discovered = self.discover()
+        loaded_count = 0
+
+        # Get enabled plugins from config
+        enabled = set(self._plugin_config.get("enabled", []))
+        disabled = set(self._plugin_config.get("disabled", []))
+
+        for plugin_name in discovered:
+            # Extract base name
+            base_name = plugin_name.split(":", 1)[-1]
+
+            # Check if enabled/disabled
+            if only_enabled:
+                if base_name in disabled:
+                    continue
+                if enabled and base_name not in enabled:
+                    continue
+
+            if self.load(plugin_name):
+                loaded_count += 1
+
+        return loaded_count
+
+    def unload(self, plugin_name: str) -> bool:
+        """Unload a plugin."""
+        with self._lock:
+            if plugin_name not in self._plugins:
+                return False
+
+            loaded = self._plugins[plugin_name]
+
+            # Check for dependents
+            for name, other in self._plugins.items():
+                if plugin_name in other.metadata.dependencies:
+                    raise RuntimeError(f"Cannot unload: {name} depends on {plugin_name}")
+
+            # Shutdown plugin
+            try:
+                loaded.plugin.shutdown()
+            except Exception:
+                pass
+
+            # Remove from hooks
+            for hook in loaded.metadata.hooks:
+                if plugin_name in self._hooks[hook]:
+                    self._hooks[hook].remove(plugin_name)
+
+            # Remove plugin
+            del self._plugins[plugin_name]
+
+            return True
+
+    def unload_all(self) -> None:
+        """Unload all plugins in reverse load order."""
+        # Sort by load order descending
+        plugins = sorted(
+            self._plugins.values(),
+            key=lambda p: p.load_order,
+            reverse=True,
+        )
+
+        for loaded in plugins:
+            try:
+                self.unload(loaded.metadata.name)
+            except Exception:
+                pass
+
+    def trigger(self, hook: PluginHook, ctx: PluginContext) -> PluginContext:
+        """
+        Trigger a hook on all registered plugins.
+
+        Args:
+            hook: The hook to trigger
+            ctx: Context to pass to plugins
+
+        Returns:
+            The context (possibly modified by plugins)
+        """
+        ctx.hook = hook
+
+        for plugin_name in self._hooks.get(hook, []):
+            if not ctx.should_continue:
+                break
+
+            loaded = self._plugins.get(plugin_name)
+            if loaded and loaded.enabled:
+                try:
+                    loaded.plugin.handle_hook(hook, ctx)
+                except Exception as e:
+                    ctx.add_warning(f"Plugin {plugin_name} error: {e}")
+
+        return ctx
+
+    def enable(self, plugin_name: str) -> bool:
+        """Enable a plugin."""
+        with self._lock:
+            if plugin_name in self._plugins:
+                self._plugins[plugin_name].enabled = True
+
+            # Update config
+            disabled = set(self._plugin_config.get("disabled", []))
+            disabled.discard(plugin_name)
+            self._plugin_config["disabled"] = list(disabled)
+
+            enabled = set(self._plugin_config.get("enabled", []))
+            enabled.add(plugin_name)
+            self._plugin_config["enabled"] = list(enabled)
+
+            self._save_config()
+            return True
+
+    def disable(self, plugin_name: str) -> bool:
+        """Disable a plugin."""
+        with self._lock:
+            if plugin_name in self._plugins:
+                self._plugins[plugin_name].enabled = False
+
+            # Update config
+            enabled = set(self._plugin_config.get("enabled", []))
+            enabled.discard(plugin_name)
+            self._plugin_config["enabled"] = list(enabled)
+
+            disabled = set(self._plugin_config.get("disabled", []))
+            disabled.add(plugin_name)
+            self._plugin_config["disabled"] = list(disabled)
+
+            self._save_config()
+            return True
+
+    def list_plugins(self) -> List[Dict[str, Any]]:
+        """List all loaded plugins."""
+        return [
+            {
+                **loaded.metadata.to_dict(),
+                "enabled": loaded.enabled,
+                "load_order": loaded.load_order,
+            }
+            for loaded in sorted(self._plugins.values(), key=lambda p: p.load_order)
+        ]
+
+    def get_plugin(self, name: str) -> Optional[Plugin]:
+        """Get a loaded plugin by name."""
+        loaded = self._plugins.get(name)
+        return loaded.plugin if loaded else None
+
+    def has_plugin(self, name: str) -> bool:
+        """Check if a plugin is loaded."""
+        return name in self._plugins
+
+
+# Global plugin manager
+_plugin_manager: Optional[PluginManager] = None
+
+
+def get_plugin_manager() -> PluginManager:
+    """Get the global plugin manager."""
+    global _plugin_manager
+    if _plugin_manager is None:
+        _plugin_manager = PluginManager()
+    return _plugin_manager
+
+
+def set_plugin_manager(manager: PluginManager) -> None:
+    """Set the global plugin manager (useful for testing)."""
+    global _plugin_manager
+    _plugin_manager = manager
+
+
+def trigger_hook(hook: PluginHook, **kwargs: Any) -> PluginContext:
+    """
+    Convenience function to trigger a hook.
+
+    Usage:
+        ctx = trigger_hook(PluginHook.POST_VM_CREATE, vm_name="my-vm")
+    """
+    ctx = PluginContext(hook=hook, **kwargs)
+    return get_plugin_manager().trigger(hook, ctx)

{clonebox-1.1.12.dist-info → clonebox-1.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 1.1.12
+Version: 1.1.14
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0

{clonebox-1.1.12.dist-info → clonebox-1.1.14.dist-info}/RECORD

@@ -1,7 +1,8 @@
 clonebox/__init__.py,sha256=CyfHVVq6KqBr4CNERBpXk_O6Q5B35q03YpdQbokVvvI,408
 clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=CcqJgVH-hSGm4FXTuJCWniocKnAeQayhPPO17nxK578,139009
-clonebox/cloner.py,sha256=sCUeGLY64rXVoEmstS5oFLbCmwwFyR8LhIzkmplMemI,96242
+clonebox/audit.py,sha256=67V2ap4QYVXH41b2GmNeRw0-0BilPPTgbDJ0eA5xv2A,14119
+clonebox/cli.py,sha256=7QCjprKNRguPVHhxXzd2ej-t61W8kOcxlSMSNxYoXag,153643
+clonebox/cloner.py,sha256=Hf4ugJ0lZ52etrnY2RoopwbMaQsPctZp5d1i3_qQKsU,97470
 clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
 clonebox/dashboard.py,sha256=dMY6odvPq3j6FronhRRsX7aY3qdCwznB-aCWKEmHDNw,5768
 clonebox/detector.py,sha256=vS65cvFNPmUBCX1Y_TMTnSRljw6r1Ae9dlVtACs5XFc,23075
@@ -11,6 +12,7 @@ clonebox/importer.py,sha256=Q9Uk1IOA41mgGhU4ynW2k-h9GEoGxRKI3c9wWE4uxcA,7097
 clonebox/logging.py,sha256=jD_WgkHmt_h99EmX82QWK7D0OKWyxqcLwgT4UDQFp2g,3675
 clonebox/models.py,sha256=13B0lVAuaGnpY4h4iYUPigIvfxYx2pWaAEM1cYF_Hbo,8263
 clonebox/monitor.py,sha256=zlIarNf8w_i34XI8hZGxxrg5PVZK_Yxm6FQnkhLavRI,9181
+clonebox/orchestrator.py,sha256=LvoDZIX47g2pdvMYfCW3NJ5sAiRYKKa45KGlujnJZuI,19871
 clonebox/p2p.py,sha256=6o0JnscKqF9-BftQhW5fF1W6YY1wXshY9LEklNcHGJc,5913
 clonebox/profiles.py,sha256=UP37fX_rhrG_O9ehNFJBUcULPmUtN1A8KsJ6cM44oK0,1986
 clonebox/resource_monitor.py,sha256=lDR9KyPbVtImeeOkOBPPVP-5yCgoL5hsVFPZ_UqsY0w,5286
@@ -29,14 +31,17 @@ clonebox/interfaces/disk.py,sha256=F7Xzj2dq5UTZ2KGCuThDM8bwTps6chFbquOUmfLREjI,9
 clonebox/interfaces/hypervisor.py,sha256=8ms4kZLA-5Ba1e_n68mCucwP_K9mufbmTBlo7XzURn4,1991
 clonebox/interfaces/network.py,sha256=YPIquxEB7sZHczbpuopcZpffTjWYI6cKmAu3wAEFllk,853
 clonebox/interfaces/process.py,sha256=njvAIZw_TCjw01KpyVQKIDoRvhTwl0FfVGbQ6mxTROk,1024
+clonebox/plugins/__init__.py,sha256=3cxlz159nokZCOL2c017WqTwt5z00yyn-o-SemP1g6c,416
+clonebox/plugins/base.py,sha256=A2H-2vrYUczNZCDioQ8cAtvaSob4YpXutx7FWMjksC4,10133
+clonebox/plugins/manager.py,sha256=gotjHloAiiADLJjATOvdBxrasU3Rc8h2fW0MwVGIhCI,14105
 clonebox/snapshots/__init__.py,sha256=ndlrIavPAiA8z4Ep3-D_EPhOcjNKYFnP3rIpEKaGdb8,273
 clonebox/snapshots/manager.py,sha256=hGzM8V6ZJPXjTqj47c4Kr8idlE-c1Q3gPUvuw1HvS1A,11393
 clonebox/snapshots/models.py,sha256=sRnn3OZE8JG9FZJlRuA3ihO-JXoPCQ3nD3SQytflAao,6206
 clonebox/templates/profiles/ml-dev.yaml,sha256=w07MToGh31xtxpjbeXTBk9BkpAN8A3gv8HeA3ESKG9M,461
 clonebox/templates/profiles/web-stack.yaml,sha256=EBnnGMzML5vAjXmIUbCpbTCwmRaNJiuWd3EcL43DOK8,485
-clonebox-1.1.12.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-1.1.12.dist-info/METADATA,sha256=VwCiMx2lcWX9XB9w89M16zRtQPuPhu1RW1KHdIxeJrA,48916
-clonebox-1.1.12.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-1.1.12.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-1.1.12.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-1.1.12.dist-info/RECORD,,
+clonebox-1.1.14.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-1.1.14.dist-info/METADATA,sha256=MCTVRt4sr9hDpl7N0x_DwR0067cNXqL-Ti1huPFVU60,48916
+clonebox-1.1.14.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-1.1.14.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-1.1.14.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-1.1.14.dist-info/RECORD,,