refactor: deep clean plugins (#31)

* refactor: deep clean plugins

* refactor: modernize plugin system with Python 3.12+ typing and simplified discovery

- Update typing to Python 3.12+ style (Dict->dict, Optional->union types)
- Simplify plugin discovery using PLUGIN_CLASS exports instead of dir() reflection
- Add public get_user_ids() and set_ownership() functions in cubbi_init
- Add create_directory_with_ownership() helper method to ToolPlugin base class
- Replace initialize() + integrate_mcp_servers() pattern with unified configure()
- Add is_already_configured() checks to prevent overwriting existing configs
- Remove excessive comments and clean up code structure
- All 5 plugins updated: goose, opencode, claudecode, aider, crush

* fix: remove duplicate

Author: tito

cubbi/images/aider/aider_plugin.py

@@ -3,26 +3,15 @@
 import os
 import stat
 from pathlib import Path
-from typing import Dict
 
-from cubbi_init import ToolPlugin, cubbi_config
+from cubbi_init import ToolPlugin, cubbi_config, set_ownership
 
 
 class AiderPlugin(ToolPlugin):
     @property
     def tool_name(self) -> str:
         return "aider"
 
-    def _get_user_ids(self) -> tuple[int, int]:
-        return cubbi_config.user.uid, cubbi_config.user.gid
-
-    def _set_ownership(self, path: Path) -> None:
-        user_id, group_id = self._get_user_ids()
-        try:
-            os.chown(path, user_id, group_id)
-        except OSError as e:
-            self.status.log(f"Failed to set ownership for {path}: {e}", "WARNING")
-
     def _get_aider_config_dir(self) -> Path:
         return Path("/home/cubbi/.aider")
 
@@ -33,28 +22,23 @@ def _ensure_aider_dirs(self) -> tuple[Path, Path]:
         config_dir = self._get_aider_config_dir()
         cache_dir = self._get_aider_cache_dir()
 
-        # Create directories
-        for directory in [config_dir, cache_dir]:
-            try:
-                directory.mkdir(mode=0o755, parents=True, exist_ok=True)
-                self._set_ownership(directory)
-            except OSError as e:
-                self.status.log(
-                    f"Failed to create Aider directory {directory}: {e}", "ERROR"
-                )
+        self.create_directory_with_ownership(config_dir)
+        self.create_directory_with_ownership(cache_dir)
 
         return config_dir, cache_dir
 
-    def initialize(self) -> bool:
+    def is_already_configured(self) -> bool:
+        config_dir = self._get_aider_config_dir()
+        env_file = config_dir / ".env"
+        return env_file.exists()
+
+    def configure(self) -> bool:
         self.status.log("Setting up Aider configuration...")
 
-        # Ensure Aider directories exist
         config_dir, cache_dir = self._ensure_aider_dirs()
 
-        # Set up environment variables for the session
         env_vars = self._create_environment_config()
 
-        # Create .env file if we have API keys
         if env_vars:
             env_file = config_dir / ".env"
             success = self._write_env_file(env_file, env_vars)
@@ -71,22 +55,26 @@ def initialize(self) -> bool:
                 "INFO",
             )
 
-        # Always return True to allow container to start
+        if not cubbi_config.mcps:
+            self.status.log("No MCP servers to integrate")
+            return True
+
+        self.status.log(
+            f"Found {len(cubbi_config.mcps)} MCP server(s) - no direct integration available for Aider"
+        )
+
         return True
 
-    def _create_environment_config(self) -> Dict[str, str]:
+    def _create_environment_config(self) -> dict[str, str]:
         env_vars = {}
 
-        # Configure Aider with the default model from cubbi config
         provider_config = cubbi_config.get_provider_for_default_model()
         if provider_config and cubbi_config.defaults.model:
             _, model_name = cubbi_config.defaults.model.split("/", 1)
 
-            # Set the model for Aider
             env_vars["AIDER_MODEL"] = model_name
             self.status.log(f"Set Aider model to {model_name}")
 
-            # Set provider-specific API key and configuration
             if provider_config.type == "anthropic":
                 env_vars["AIDER_ANTHROPIC_API_KEY"] = provider_config.api_key
                 self.status.log("Configured Anthropic API key for Aider")
@@ -100,10 +88,7 @@ def _create_environment_config(self) -> Dict[str, str]:
                     )
                 self.status.log("Configured OpenAI API key for Aider")
 
-            # Note: Aider uses different environment variable names for some providers
-            # We map cubbi provider types to Aider's expected variable names
             elif provider_config.type == "google":
-                # Aider may expect GEMINI_API_KEY for Google models
                 env_vars["GEMINI_API_KEY"] = provider_config.api_key
                 self.status.log("Configured Google/Gemini API key for Aider")
 
@@ -122,7 +107,6 @@ def _create_environment_config(self) -> Dict[str, str]:
                 "WARNING",
             )
 
-            # Fallback to legacy environment variable checking for backward compatibility
             api_key_mappings = {
                 "OPENAI_API_KEY": "AIDER_OPENAI_API_KEY",
                 "ANTHROPIC_API_KEY": "AIDER_ANTHROPIC_API_KEY",
@@ -138,25 +122,21 @@ def _create_environment_config(self) -> Dict[str, str]:
                     provider = env_var.replace("_API_KEY", "").lower()
                     self.status.log(f"Added {provider} API key from environment")
 
-            # Check for OpenAI API base URL from legacy environment
             openai_url = os.environ.get("OPENAI_URL")
             if openai_url:
                 env_vars["AIDER_OPENAI_API_BASE"] = openai_url
                 self.status.log(
                     f"Set OpenAI API base URL to {openai_url} from environment"
                 )
 
-            # Legacy model configuration
             model = os.environ.get("AIDER_MODEL")
             if model:
                 env_vars["AIDER_MODEL"] = model
                 self.status.log(f"Set model to {model} from environment")
 
-        # Handle additional API keys from AIDER_API_KEYS
         additional_keys = os.environ.get("AIDER_API_KEYS")
         if additional_keys:
             try:
-                # Parse format: "provider1=key1,provider2=key2"
                 for pair in additional_keys.split(","):
                     if "=" in pair:
                         provider, key = pair.strip().split("=", 1)
@@ -166,17 +146,14 @@ def _create_environment_config(self) -> Dict[str, str]:
             except Exception as e:
                 self.status.log(f"Failed to parse AIDER_API_KEYS: {e}", "WARNING")
 
-        # Add git configuration
         auto_commits = os.environ.get("AIDER_AUTO_COMMITS", "true")
         if auto_commits.lower() in ["true", "false"]:
             env_vars["AIDER_AUTO_COMMITS"] = auto_commits
 
-        # Add dark mode setting
         dark_mode = os.environ.get("AIDER_DARK_MODE", "false")
         if dark_mode.lower() in ["true", "false"]:
             env_vars["AIDER_DARK_MODE"] = dark_mode
 
-        # Add proxy settings
         for proxy_var in ["HTTP_PROXY", "HTTPS_PROXY"]:
             value = os.environ.get(proxy_var)
             if value:
@@ -185,16 +162,15 @@ def _create_environment_config(self) -> Dict[str, str]:
 
         return env_vars
 
-    def _write_env_file(self, env_file: Path, env_vars: Dict[str, str]) -> bool:
+    def _write_env_file(self, env_file: Path, env_vars: dict[str, str]) -> bool:
         try:
             content = "\n".join(f"{key}={value}" for key, value in env_vars.items())
 
             with open(env_file, "w") as f:
                 f.write(content)
                 f.write("\n")
 
-            # Set ownership and secure file permissions (read/write for owner only)
-            self._set_ownership(env_file)
+            set_ownership(env_file)
             os.chmod(env_file, stat.S_IRUSR | stat.S_IWUSR)
 
             self.status.log(f"Created Aider environment file at {env_file}")
@@ -203,18 +179,5 @@ def _write_env_file(self, env_file: Path, env_vars: Dict[str, str]) -> bool:
             self.status.log(f"Failed to write Aider environment file: {e}", "ERROR")
             return False
 
-    def setup_tool_configuration(self) -> bool:
-        # Additional tool configuration can be added here if needed
-        return True
-
-    def integrate_mcp_servers(self) -> bool:
-        if not cubbi_config.mcps:
-            self.status.log("No MCP servers to integrate")
-            return True
 
-        # Aider doesn't have native MCP support like Claude Code,
-        # but we could potentially add custom integrations here
-        self.status.log(
-            f"Found {len(cubbi_config.mcps)} MCP server(s) - no direct integration available for Aider"
-        )
-        return True
+PLUGIN_CLASS = AiderPlugin

cubbi/images/claudecode/claudecode_plugin.py

@@ -4,56 +4,36 @@
 import os
 import stat
 from pathlib import Path
-from typing import Dict, Optional
 
-from cubbi_init import ToolPlugin, cubbi_config
+from cubbi_init import ToolPlugin, cubbi_config, set_ownership
 
 
 class ClaudeCodePlugin(ToolPlugin):
     @property
     def tool_name(self) -> str:
         return "claudecode"
 
-    def _get_user_ids(self) -> tuple[int, int]:
-        return cubbi_config.user.uid, cubbi_config.user.gid
-
-    def _set_ownership(self, path: Path) -> None:
-        user_id, group_id = self._get_user_ids()
-        try:
-            os.chown(path, user_id, group_id)
-        except OSError as e:
-            self.status.log(f"Failed to set ownership for {path}: {e}", "WARNING")
-
     def _get_claude_dir(self) -> Path:
         return Path("/home/cubbi/.claude")
 
-    def _ensure_claude_dir(self) -> Path:
-        claude_dir = self._get_claude_dir()
+    def is_already_configured(self) -> bool:
+        settings_file = self._get_claude_dir() / "settings.json"
+        return settings_file.exists()
 
-        try:
-            claude_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
-            self._set_ownership(claude_dir)
-        except OSError as e:
-            self.status.log(
-                f"Failed to create Claude directory {claude_dir}: {e}", "ERROR"
-            )
-
-        return claude_dir
-
-    def initialize(self) -> bool:
+    def configure(self) -> bool:
         self.status.log("Setting up Claude Code authentication...")
 
-        # Ensure Claude directory exists
-        claude_dir = self._ensure_claude_dir()
+        claude_dir = self.create_directory_with_ownership(self._get_claude_dir())
+        claude_dir.chmod(0o700)
 
-        # Create settings configuration
         settings = self._create_settings()
 
         if settings:
             settings_file = claude_dir / "settings.json"
             success = self._write_settings(settings_file, settings)
             if success:
                 self.status.log("✅ Claude Code authentication configured successfully")
+                self._integrate_mcp_servers()
                 return True
             else:
                 return False
@@ -63,53 +43,52 @@ def initialize(self) -> bool:
                 "   Please set ANTHROPIC_API_KEY environment variable", "WARNING"
             )
             self.status.log("   Claude Code will run without authentication", "INFO")
-            # Return True to allow container to start without API key
-            # Users can still use Claude Code with their own authentication methods
+            self._integrate_mcp_servers()
             return True
 
-    def _create_settings(self) -> Optional[Dict]:
+    def _integrate_mcp_servers(self) -> None:
+        if not cubbi_config.mcps:
+            self.status.log("No MCP servers to integrate")
+            return
+
+        self.status.log("MCP server integration available for Claude Code")
+
+    def _create_settings(self) -> dict | None:
         settings = {}
 
-        # Get Anthropic provider configuration from cubbi_config
         anthropic_provider = None
         for provider_name, provider_config in cubbi_config.providers.items():
             if provider_config.type == "anthropic":
                 anthropic_provider = provider_config
                 break
 
         if not anthropic_provider or not anthropic_provider.api_key:
-            # Fallback to environment variable for backward compatibility
             api_key = os.environ.get("ANTHROPIC_API_KEY")
             if not api_key:
                 return None
             settings["apiKey"] = api_key
         else:
             settings["apiKey"] = anthropic_provider.api_key
 
-        # Custom authorization token (optional) - still from environment
         auth_token = os.environ.get("ANTHROPIC_AUTH_TOKEN")
         if auth_token:
             settings["authToken"] = auth_token
 
-        # Custom headers (optional) - still from environment
         custom_headers = os.environ.get("ANTHROPIC_CUSTOM_HEADERS")
         if custom_headers:
             try:
-                # Expect JSON string format
                 settings["customHeaders"] = json.loads(custom_headers)
             except json.JSONDecodeError:
                 self.status.log(
                     "⚠️ Invalid ANTHROPIC_CUSTOM_HEADERS format, skipping", "WARNING"
                 )
 
-        # Enterprise integration settings - still from environment
         if os.environ.get("CLAUDE_CODE_USE_BEDROCK") == "true":
             settings["provider"] = "bedrock"
 
         if os.environ.get("CLAUDE_CODE_USE_VERTEX") == "true":
             settings["provider"] = "vertex"
 
-        # Network proxy settings - still from environment
         http_proxy = os.environ.get("HTTP_PROXY")
         https_proxy = os.environ.get("HTTPS_PROXY")
         if http_proxy or https_proxy:
@@ -119,11 +98,9 @@ def _create_settings(self) -> Optional[Dict]:
             if https_proxy:
                 settings["proxy"]["https"] = https_proxy
 
-        # Telemetry settings - still from environment
         if os.environ.get("DISABLE_TELEMETRY") == "true":
             settings["telemetry"] = {"enabled": False}
 
-        # Tool permissions (allow all by default in Cubbi environment)
         settings["permissions"] = {
             "tools": {
                 "read": {"allowed": True},
@@ -137,14 +114,12 @@ def _create_settings(self) -> Optional[Dict]:
 
         return settings
 
-    def _write_settings(self, settings_file: Path, settings: Dict) -> bool:
+    def _write_settings(self, settings_file: Path, settings: dict) -> bool:
         try:
-            # Write settings with secure permissions
             with open(settings_file, "w") as f:
                 json.dump(settings, f, indent=2)
 
-            # Set ownership and secure file permissions (read/write for owner only)
-            self._set_ownership(settings_file)
+            set_ownership(settings_file)
             os.chmod(settings_file, stat.S_IRUSR | stat.S_IWUSR)
 
             self.status.log(f"Created Claude Code settings at {settings_file}")
@@ -153,16 +128,5 @@ def _write_settings(self, settings_file: Path, settings: Dict) -> bool:
             self.status.log(f"Failed to write Claude Code settings: {e}", "ERROR")
             return False
 
-    def setup_tool_configuration(self) -> bool:
-        # Additional tool configuration can be added here if needed
-        return True
 
-    def integrate_mcp_servers(self) -> bool:
-        if not cubbi_config.mcps:
-            self.status.log("No MCP servers to integrate")
-            return True
-
-        # Claude Code has built-in MCP support, so we can potentially
-        # configure MCP servers in the settings if needed
-        self.status.log("MCP server integration available for Claude Code")
-        return True
+PLUGIN_CLASS = ClaudeCodePlugin