fix: Address high-severity bandit issues

dss-claude-plugin/core/context.py

@@ -8,7 +8,7 @@ Handles configuration loading, mode detection, and strategy instantiation.
 
 import asyncio
 import logging
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
 
 from .config import DSSConfig, DSSMode
 
@@ -26,12 +26,15 @@ class DSSContext:
     Handles configuration loading, mode detection (Local/Remote),
     and strategy instantiation.
     """
-    _instance: Optional['DSSContext'] = None
+
+    _instance: Optional["DSSContext"] = None
     _lock: asyncio.Lock = asyncio.Lock()
 
     def __init__(self) -> None:
         """
-        Private initializer. Use get_instance() instead.
+        Private initializer.
+
+        Use get_instance() instead.
         """
         if DSSContext._instance is not None:
             raise RuntimeError("DSSContext is a singleton. Use get_instance() to access it.")
@@ -43,9 +46,10 @@ class DSSContext:
         self.session_id: Optional[str] = None
 
     @classmethod
-    async def get_instance(cls) -> 'DSSContext':
+    async def get_instance(cls) -> "DSSContext":
         """
         Async factory method to get the singleton instance.
+
         Ensures config is loaded and mode is detected before returning.
         """
         if not cls._instance:
@@ -61,13 +65,16 @@ class DSSContext:
     @classmethod
     def reset(cls) -> None:
         """
-        Resets the singleton instance. Useful for testing.
+        Resets the singleton instance.
+
+        Useful for testing.
         """
         cls._instance = None
 
     async def _initialize(self) -> None:
         """
         Internal initialization logic:
+
         1. Load Config
         2. Detect Mode
         3. Cache Capabilities
@@ -80,7 +87,9 @@ class DSSContext:
             # 2. Detect Mode (Async check)
             self.active_mode = await self.config.get_active_mode()
 
-            logger.info(f"DSSContext initialized. Mode: {self.active_mode.value}, Session: {self.session_id}")
+            logger.info(
+                f"DSSContext initialized. Mode: {self.active_mode.value}, Session: {self.session_id}"
+            )
 
             # 3. Cache Capabilities
             self._cache_capabilities()
@@ -92,15 +101,13 @@ class DSSContext:
             self._capabilities = {"limited": True}
 
     def _cache_capabilities(self) -> None:
-        """
-        Determines what the plugin can do based on the active mode.
-        """
+        """Determines what the plugin can do based on the active mode."""
         # Base capabilities
         caps = {
             "can_read_files": False,
             "can_execute_browser": False,
             "can_screenshot": False,
-            "can_connect_remote": True
+            "can_connect_remote": True,
         }
 
         if self.active_mode == DSSMode.LOCAL:
@@ -111,8 +118,10 @@ class DSSContext:
         elif self.active_mode == DSSMode.REMOTE:
             # Remote mode relies on API capabilities
             # Depending on remote configuration, these might differ
-            caps["can_execute_browser"] = False  # Typically restricted in pure remote unless via API
-            caps["can_read_files"] = False       # Security restriction
+            caps[
+                "can_execute_browser"
+            ] = False  # Typically restricted in pure remote unless via API
+            caps["can_read_files"] = False  # Security restriction
 
         self._capabilities = caps
 
@@ -151,18 +160,22 @@ class DSSContext:
                 # Will be implemented in Phase 2 & 3
                 if self.active_mode == DSSMode.LOCAL:
                     from ..strategies.local.browser import LocalBrowserStrategy
+
                     strategy_instance = LocalBrowserStrategy(self)
                 else:
                     from ..strategies.remote.browser import RemoteBrowserStrategy
+
                     strategy_instance = RemoteBrowserStrategy(self)
 
             elif strategy_type == "filesystem":
                 # Will be implemented in Phase 2
                 if self.active_mode == DSSMode.LOCAL:
                     from ..strategies.local.filesystem import LocalFilesystemStrategy
+
                     strategy_instance = LocalFilesystemStrategy(self)
                 else:
                     from ..strategies.remote.filesystem import RemoteFilesystemStrategy
+
                     strategy_instance = RemoteFilesystemStrategy(self)
 
             elif strategy_type == "screenshot":