tweek 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

tweek/platform/__init__.py

@@ -4,8 +4,10 @@ Platform detection and cross-platform support for Tweek.
 Tweek supports:
 - macOS: Full support (Keychain via keyring, sandbox-exec)
 - Linux: Full support (Secret Service via keyring, firejail optional)
-- Windows: Partial support (Credential Locker via keyring, no sandbox)
+
+Windows is not supported.
 """
+from __future__ import annotations
 
 import platform
 import shutil
@@ -92,9 +94,7 @@ def get_vault_backend() -> str:
         return "macOS Keychain"
     elif IS_LINUX:
         return "Secret Service (GNOME Keyring/KWallet)"
-    elif IS_WINDOWS:
-        return "Windows Credential Locker"
-    return "Unknown"
+    return "Not supported"
 
 
 def get_capabilities() -> PlatformCapabilities:

tweek/plugins/__init__.py

@@ -5,7 +5,7 @@ Tweek Plugin System
 Modular plugin architecture supporting:
 - Domain compliance modules (Gov, HIPAA, PCI, Legal)
 - LLM provider plugins (Anthropic, OpenAI, Google, Bedrock)
-- Tool detector plugins (moltbot, Cursor, Continue)
+- Tool detector plugins (openclaw, Cursor, Continue)
 - Screening method plugins (rate limiting, pattern matching, LLM review)
 
 Plugin Discovery:
@@ -43,7 +43,7 @@ class PluginCategory(Enum):
     """Categories of plugins supported by Tweek."""
     COMPLIANCE = "tweek.compliance"          # Gov, HIPAA, PCI, Legal
     LLM_PROVIDER = "tweek.llm_providers"     # Anthropic, OpenAI, etc.
-    TOOL_DETECTOR = "tweek.tool_detectors"   # moltbot, Cursor, etc.
+    TOOL_DETECTOR = "tweek.tool_detectors"   # openclaw, Cursor, etc.
     SCREENING = "tweek.screening"            # rate_limiter, pattern_matcher
 
 
@@ -248,7 +248,7 @@ class PluginRegistry:
                     f"Git plugin {name} overriding builtin in {category.value}"
                 )
             else:
-                logger.warning(f"Plugin {name} already registered in {category.value}")
+                logger.debug(f"Plugin {name} already registered in {category.value}")
                 return False
 
         # Create plugin info
@@ -551,6 +551,7 @@ class PluginRegistry:
 
 # Global registry instance
 _registry: Optional[PluginRegistry] = None
+_initialized: bool = False
 
 
 def get_registry() -> PluginRegistry:
@@ -578,6 +579,7 @@ def init_plugins(config: Optional[Dict[str, Any]] = None) -> PluginRegistry:
     3. Entry point plugins (from installed packages)
 
     Git plugins with the same name as a builtin will override the builtin.
+    Safe to call multiple times — plugin discovery only runs once.
 
     Args:
         config: Optional configuration dictionary
@@ -585,31 +587,35 @@ def init_plugins(config: Optional[Dict[str, Any]] = None) -> PluginRegistry:
     Returns:
         The initialized plugin registry
     """
+    global _initialized
     registry = get_registry()
 
-    # Log startup
-    try:
-        from tweek.logging.security_log import get_logger as get_sec_logger, SecurityEvent, EventType
-        get_sec_logger().log(SecurityEvent(
-            event_type=EventType.STARTUP,
-            tool_name="plugin_system",
-            decision="allow",
-            metadata={"operation": "init_plugins"},
-            source="plugins",
-        ))
-    except Exception:
-        pass
+    if not _initialized:
+        # Log startup
+        try:
+            from tweek.logging.security_log import get_logger as get_sec_logger, SecurityEvent, EventType
+            get_sec_logger().log(SecurityEvent(
+                event_type=EventType.STARTUP,
+                tool_name="plugin_system",
+                decision="allow",
+                metadata={"operation": "init_plugins"},
+                source="plugins",
+            ))
+        except Exception:
+            pass
 
-    # Register built-in plugins
-    _register_builtin_plugins(registry)
+        # Register built-in plugins
+        _register_builtin_plugins(registry)
 
-    # Discover git-installed plugins
-    _discover_git_plugins(registry)
+        # Discover git-installed plugins
+        _discover_git_plugins(registry)
 
-    # Discover external plugins via entry_points
-    registry.discover_plugins()
+        # Discover external plugins via entry_points
+        registry.discover_plugins()
 
-    # Load configuration
+        _initialized = True
+
+    # Load configuration (always applied, even on subsequent calls)
     if config:
         registry.load_config(config)
 
@@ -688,13 +694,13 @@ def _register_builtin_plugins(registry: PluginRegistry) -> None:
     # Detector plugins
     try:
         from tweek.plugins.detectors import (
-            MoltbotDetector,
+            OpenClawDetector,
             CursorDetector,
             ContinueDetector,
             CopilotDetector,
             WindsurfDetector,
         )
-        registry.register("moltbot", MoltbotDetector, PluginCategory.TOOL_DETECTOR)
+        registry.register("openclaw", OpenClawDetector, PluginCategory.TOOL_DETECTOR)
         registry.register("cursor", CursorDetector, PluginCategory.TOOL_DETECTOR)
         registry.register("continue", ContinueDetector, PluginCategory.TOOL_DETECTOR)
         registry.register("copilot", CopilotDetector, PluginCategory.TOOL_DETECTOR)
@@ -707,16 +713,26 @@ def _register_builtin_plugins(registry: PluginRegistry) -> None:
         from tweek.plugins.screening import (
             RateLimiterPlugin,
             PatternMatcherPlugin,
+            HeuristicScorerPlugin,
             LLMReviewerPlugin,
             SessionAnalyzerPlugin,
         )
         registry.register("rate_limiter", RateLimiterPlugin, PluginCategory.SCREENING)
         registry.register("pattern_matcher", PatternMatcherPlugin, PluginCategory.SCREENING)
+        registry.register("heuristic_scorer", HeuristicScorerPlugin, PluginCategory.SCREENING)
         registry.register("llm_reviewer", LLMReviewerPlugin, PluginCategory.SCREENING)
         registry.register("session_analyzer", SessionAnalyzerPlugin, PluginCategory.SCREENING)
     except ImportError as e:
         logger.debug(f"Screening plugins not available: {e}")
 
+    # Local model reviewer plugin (optional — requires tweek[local-models])
+    try:
+        from tweek.plugins.screening.local_model_reviewer import LocalModelReviewerPlugin
+        if LocalModelReviewerPlugin is not None:
+            registry.register("local_model_reviewer", LocalModelReviewerPlugin, PluginCategory.SCREENING)
+    except ImportError:
+        pass
+
 
 def _discover_git_plugins(registry: PluginRegistry) -> int:
     """

tweek/plugins/base.py

@@ -854,7 +854,7 @@ class ToolDetectorPlugin(ABC):
     @property
     @abstractmethod
     def name(self) -> str:
-        """Tool name (e.g., 'moltbot', 'cursor')."""
+        """Tool name (e.g., 'openclaw', 'cursor')."""
         pass
 
     @abstractmethod

tweek/plugins/detectors/__init__.py

@@ -3,7 +3,7 @@
 Tweek Tool Detector Plugins
 
 Detector plugins identify installed LLM tools and IDEs:
-- Moltbot: AI coding assistant
+- OpenClaw: AI personal assistant
 - Cursor: AI-powered IDE
 - Continue.dev: VS Code AI extension
 - Copilot: GitHub Copilot
@@ -15,14 +15,14 @@ Detection helps:
 - Suggest integration options
 """
 
-from tweek.plugins.detectors.moltbot import MoltbotDetector
+from tweek.plugins.detectors.openclaw import OpenClawDetector
 from tweek.plugins.detectors.cursor import CursorDetector
 from tweek.plugins.detectors.continue_dev import ContinueDetector
 from tweek.plugins.detectors.copilot import CopilotDetector
 from tweek.plugins.detectors.windsurf import WindsurfDetector
 
 __all__ = [
-    "MoltbotDetector",
+    "OpenClawDetector",
     "CursorDetector",
     "ContinueDetector",
     "CopilotDetector",

tweek/plugins/detectors/{moltbot.py → openclaw.py}

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """
-Tweek Moltbot Detector Plugin
+Tweek OpenClaw Detector Plugin
 
-Detects Moltbot AI coding assistant:
+Detects OpenClaw AI personal assistant:
 - Global npm installation
 - Running process
 - Gateway configuration
@@ -17,36 +17,35 @@ from typing import Optional, List, Dict, Any
 from tweek.plugins.base import ToolDetectorPlugin, DetectionResult
 
 
-class MoltbotDetector(ToolDetectorPlugin):
+class OpenClawDetector(ToolDetectorPlugin):
     """
-    Moltbot AI coding assistant detector.
+    OpenClaw AI personal assistant detector.
 
     Detects:
     - npm global installation
-    - Running moltbot process
+    - Running openclaw process
     - Gateway service on default port
     - Configuration file location
     """
 
     VERSION = "1.0.0"
-    DESCRIPTION = "Detect Moltbot AI coding assistant"
+    DESCRIPTION = "Detect OpenClaw AI personal assistant"
     AUTHOR = "Tweek"
     REQUIRES_LICENSE = "free"
-    TAGS = ["detector", "moltbot", "ide"]
+    TAGS = ["detector", "openclaw", "assistant"]
 
-    DEFAULT_PORT = 8080
+    DEFAULT_PORT = 18789
     CONFIG_LOCATIONS = [
-        Path.home() / ".moltbot" / "config.json",
-        Path.home() / ".config" / "moltbot" / "config.json",
+        Path.home() / ".openclaw" / "openclaw.json",
     ]
 
     @property
     def name(self) -> str:
-        return "moltbot"
+        return "openclaw"
 
     def detect(self) -> DetectionResult:
         """
-        Detect Moltbot installation and status.
+        Detect OpenClaw installation and status.
         """
         result = DetectionResult(
             detected=False,
@@ -74,6 +73,11 @@ class MoltbotDetector(ToolDetectorPlugin):
             except (json.JSONDecodeError, IOError):
                 result.port = self.DEFAULT_PORT
 
+        # Check for home directory existence
+        openclaw_home = Path.home() / ".openclaw"
+        if openclaw_home.exists():
+            result.detected = True
+
         # Check for running process
         process_info = self._check_running_process()
         if process_info:
@@ -90,11 +94,11 @@ class MoltbotDetector(ToolDetectorPlugin):
         return result
 
     def _check_npm_installation(self) -> Optional[Dict[str, str]]:
-        """Check if moltbot is installed via npm."""
+        """Check if openclaw is installed via npm."""
         try:
             # Try npm list -g
             proc = subprocess.run(
-                ["npm", "list", "-g", "moltbot", "--json"],
+                ["npm", "list", "-g", "openclaw", "--json"],
                 capture_output=True,
                 text=True,
                 timeout=10,
@@ -102,9 +106,9 @@ class MoltbotDetector(ToolDetectorPlugin):
             if proc.returncode == 0:
                 data = json.loads(proc.stdout)
                 deps = data.get("dependencies", {})
-                if "moltbot" in deps:
+                if "openclaw" in deps:
                     return {
-                        "version": deps["moltbot"].get("version", "unknown"),
+                        "version": deps["openclaw"].get("version", "unknown"),
                         "path": data.get("path", ""),
                     }
         except (subprocess.TimeoutExpired, json.JSONDecodeError, FileNotFoundError):
@@ -113,7 +117,7 @@ class MoltbotDetector(ToolDetectorPlugin):
         # Try which/where
         try:
             proc = subprocess.run(
-                ["which", "moltbot"] if os.name != "nt" else ["where", "moltbot"],
+                ["which", "openclaw"] if os.name != "nt" else ["where", "openclaw"],
                 capture_output=True,
                 text=True,
                 timeout=5,
@@ -126,14 +130,14 @@ class MoltbotDetector(ToolDetectorPlugin):
         return None
 
     def _find_config(self) -> Optional[Path]:
-        """Find moltbot config file."""
+        """Find OpenClaw config file."""
         for path in self.CONFIG_LOCATIONS:
             if path.exists():
                 return path
         return None
 
     def _check_running_process(self) -> Optional[Dict[str, Any]]:
-        """Check if moltbot process is running."""
+        """Check if openclaw process is running."""
         try:
             if os.name == "nt":
                 # Windows
@@ -143,13 +147,12 @@ class MoltbotDetector(ToolDetectorPlugin):
                     text=True,
                     timeout=10,
                 )
-                # This is a rough check - would need more sophisticated detection
-                if "moltbot" in proc.stdout.lower():
+                if "openclaw" in proc.stdout.lower():
                     return {"running": True}
             else:
                 # Unix-like
                 proc = subprocess.run(
-                    ["pgrep", "-f", "moltbot"],
+                    ["pgrep", "-f", "openclaw"],
                     capture_output=True,
                     text=True,
                     timeout=10,
@@ -158,9 +161,9 @@ class MoltbotDetector(ToolDetectorPlugin):
                     pids = proc.stdout.strip().split("\n")
                     return {"pid": pids[0]}
 
-                # Also check for node process with moltbot
+                # Also check for node process with openclaw
                 proc = subprocess.run(
-                    ["pgrep", "-af", "node.*moltbot"],
+                    ["pgrep", "-af", "node.*openclaw"],
                     capture_output=True,
                     text=True,
                     timeout=10,
@@ -174,7 +177,7 @@ class MoltbotDetector(ToolDetectorPlugin):
         return None
 
     def _check_gateway_active(self, port: int) -> bool:
-        """Check if moltbot gateway is listening on port."""
+        """Check if OpenClaw gateway is listening on port."""
         try:
             import socket
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -193,12 +196,12 @@ class MoltbotDetector(ToolDetectorPlugin):
         if result.detected:
             if result.metadata.get("gateway_active"):
                 conflicts.append(
-                    f"Moltbot gateway is active on port {result.port}. "
+                    f"OpenClaw gateway is active on port {result.port}. "
                     "This may intercept LLM API calls before Tweek."
                 )
             elif result.running:
                 conflicts.append(
-                    "Moltbot process is running. Gateway may start and "
+                    "OpenClaw process is running. Gateway may start and "
                     "intercept LLM API calls."
                 )
 

tweek/plugins/git_discovery.py

@@ -242,8 +242,12 @@ def _import_plugin_class(
 
     module_name, class_name = entry_point.split(":", 1)
 
-    # Construct file path
-    module_file = plugin_dir / f"{module_name}.py"
+    # Construct file path and validate against path traversal
+    module_file = (plugin_dir / f"{module_name}.py").resolve()
+    if not module_file.is_relative_to(plugin_dir.resolve()):
+        raise PluginDiscoveryError(
+            f"Entry point module '{module_name}' escapes plugin directory (path traversal blocked)"
+        )
     if not module_file.exists():
         raise PluginDiscoveryError(
             f"Entry point module '{module_name}.py' not found in {plugin_dir}"
@@ -266,13 +270,21 @@ def _import_plugin_class(
         module = importlib.util.module_from_spec(spec)
 
         # Add plugin directory to the module's path for relative imports
-        if plugin_dir not in sys.path:
+        # Use try/finally to ensure sys.path is always cleaned up
+        path_added = False
+        if str(plugin_dir) not in sys.path:
             sys.path.insert(0, str(plugin_dir))
+            path_added = True
 
         # Register the module in sys.modules before executing
         sys.modules[full_module_name] = module
 
-        spec.loader.exec_module(module)
+        try:
+            spec.loader.exec_module(module)
+        finally:
+            # Always remove plugin dir from sys.path to prevent pollution
+            if path_added and str(plugin_dir) in sys.path:
+                sys.path.remove(str(plugin_dir))
 
         # Get the class
         if not hasattr(module, class_name):

tweek/plugins/git_registry.py

@@ -365,8 +365,11 @@ class PluginRegistryClient:
         """Verify the HMAC signature of the registry."""
         signature = registry.get("registry_signature", "")
         if not signature:
-            logger.warning("Registry has no signature - skipping verification")
-            return True  # Allow unsigned registries in development
+            if not self._signing_key:
+                logger.warning("Registry has no signature and no signing key configured — allowing in dev mode")
+                return True
+            logger.warning("Registry has no signature but signing key is configured — rejecting")
+            return False
 
         # Sign the plugins array (the payload)
         plugins_json = json.dumps(
@@ -375,6 +378,9 @@ class PluginRegistryClient:
             separators=(",", ":"),
         ).encode()
 
+        if not self._signing_key:
+            logger.warning("Registry has signature but no signing key configured — cannot verify, rejecting")
+            return False
         key = self._signing_key.encode()
         expected_sig = hmac.new(key, plugins_json, hashlib.sha256).hexdigest()
         return hmac.compare_digest(expected_sig, signature)

tweek/plugins/git_security.py

@@ -25,13 +25,10 @@ from typing import Dict, List, Optional, Tuple, Type
 logger = logging.getLogger(__name__)
 
 # Signing key for plugin verification.
-# In production, this would use asymmetric keys (Ed25519).
-# The HMAC approach is simpler and sufficient for the curated model
-# where Tweek controls both signing and verification.
-TWEEK_SIGNING_KEY = os.environ.get(
-    "TWEEK_PLUGIN_SIGNING_KEY",
-    "tweek-plugin-signing-key-v1"
-)
+# SECURITY: No hardcoded fallback. Set TWEEK_PLUGIN_SIGNING_KEY env var
+# for plugin signature verification. Without it, signature checks will
+# fail (which is the correct behavior — fail closed).
+TWEEK_SIGNING_KEY = os.environ.get("TWEEK_PLUGIN_SIGNING_KEY", "")
 
 # Modules/functions that are forbidden in plugin code
 FORBIDDEN_IMPORTS = frozenset({
@@ -57,6 +54,8 @@ FORBIDDEN_IMPORTS = frozenset({
     "os.spawnvpe",
     "ctypes",
     "multiprocessing",
+    "importlib",
+    "importlib.util",
 })
 
 FORBIDDEN_CALLS = frozenset({
@@ -72,6 +71,9 @@ FORBIDDEN_CALLS = frozenset({
     "os.removedirs",
     "shutil.rmtree",
     "shutil.move",
+    "importlib.import_module",
+    "importlib.util.spec_from_file_location",
+    "getattr",
 })
 
 # Modules that indicate network access
@@ -215,7 +217,11 @@ def verify_checksum_signature(
     Returns:
         True if signature is valid
     """
-    key = (signing_key or TWEEK_SIGNING_KEY).encode()
+    key_str = signing_key or TWEEK_SIGNING_KEY
+    if not key_str:
+        logger.warning("TWEEK_PLUGIN_SIGNING_KEY not configured — rejecting signature (fail closed)")
+        return False
+    key = key_str.encode()
     expected_sig = hmac.new(key, checksums_content, hashlib.sha256).hexdigest()
     return hmac.compare_digest(expected_sig, signature)
 
@@ -477,6 +483,12 @@ def sign_checksums(checksums_content: bytes, signing_key: str = None) -> str:
 
     Returns:
         Hex-encoded HMAC signature
+
+    Raises:
+        ValueError: If signing key is empty/not configured
     """
-    key = (signing_key or TWEEK_SIGNING_KEY).encode()
+    key_str = signing_key or TWEEK_SIGNING_KEY
+    if not key_str:
+        raise ValueError("Cannot sign checksums: TWEEK_PLUGIN_SIGNING_KEY not configured")
+    key = key_str.encode()
     return hmac.new(key, checksums_content, hashlib.sha256).hexdigest()

tweek/plugins/screening/__init__.py

@@ -5,22 +5,31 @@ Tweek Screening Plugins
 Screening plugins provide security analysis methods:
 - RateLimiter: Detect burst patterns and abuse
 - PatternMatcher: Regex-based pattern matching
+- HeuristicScorer: Signal-based scoring for confidence-gated LLM escalation
 - LLMReviewer: Semantic analysis using LLM
 - SessionAnalyzer: Cross-turn anomaly detection
 
 License tiers:
-- FREE: PatternMatcher (basic patterns)
+- FREE: PatternMatcher (basic patterns), HeuristicScorer
 - PRO: RateLimiter, LLMReviewer, SessionAnalyzer
 """
 
 from tweek.plugins.screening.rate_limiter import RateLimiterPlugin
 from tweek.plugins.screening.pattern_matcher import PatternMatcherPlugin
+from tweek.plugins.screening.heuristic_scorer import HeuristicScorerPlugin
 from tweek.plugins.screening.llm_reviewer import LLMReviewerPlugin
 from tweek.plugins.screening.session_analyzer import SessionAnalyzerPlugin
 
+try:
+    from tweek.plugins.screening.local_model_reviewer import LocalModelReviewerPlugin
+except ImportError:
+    LocalModelReviewerPlugin = None  # type: ignore[assignment,misc]
+
 __all__ = [
     "RateLimiterPlugin",
     "PatternMatcherPlugin",
+    "HeuristicScorerPlugin",
     "LLMReviewerPlugin",
+    "LocalModelReviewerPlugin",
     "SessionAnalyzerPlugin",
 ]