devorch 0.1.2__py3-none-any.whl

config/permissions.py

@@ -0,0 +1,285 @@
+"""
+Permission management for tool execution safety.
+
+Supports:
+- Tool-level permissions (allow/deny/ask)
+- Command pattern matching (e.g., "git *" always allowed)
+- Session-only vs persistent permissions
+- Safe command categories
+"""
+
+import fnmatch
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+
+try:
+    import yaml
+
+    YAML_AVAILABLE = True
+except ImportError:
+    YAML_AVAILABLE = False
+
+CONFIG_DIR = Path.home() / ".devorch"
+PERMISSIONS_FILE = CONFIG_DIR / "permissions.yaml"
+
+
+class PermissionLevel(str, Enum):
+    ALLOW = "allow"  # Always allow without asking
+    DENY = "deny"  # Always deny
+    ASK = "ask"  # Ask every time (default)
+
+
+class PermissionChoice(str, Enum):
+    ALLOW_ONCE = "allow_once"
+    ALLOW_SESSION = "allow_session"
+    ALLOW_ALWAYS = "allow_always"
+    DENY = "deny"
+
+
+# Commands that are generally safe (read-only or low risk)
+SAFE_COMMANDS = [
+    # Version/info commands
+    "git --version",
+    "git status",
+    "git log*",
+    "git diff*",
+    "git branch*",
+    "git remote -v",
+    "git show*",
+    "python --version",
+    "python3 --version",
+    "pip --version",
+    "pip list",
+    "node --version",
+    "npm --version",
+    "npm list*",
+    "cargo --version",
+    "rustc --version",
+    "go version",
+    # List/read commands
+    "ls*",
+    "dir*",
+    "pwd",
+    "cd*",
+    "echo*",
+    "cat*",
+    "head*",
+    "tail*",
+    "which*",
+    "where*",
+    "type*",
+    "file*",
+    "wc*",
+    "grep*",
+    "find*",
+    "tree*",
+    # Environment
+    "env",
+    "printenv*",
+    "hostname",
+    "whoami",
+    "date",
+    "uptime",
+]
+
+# Commands that are potentially dangerous
+DANGEROUS_PATTERNS = [
+    "rm -rf *",
+    "rm -r *",
+    "rmdir*",
+    "del /s*",
+    "rd /s*",
+    "format*",
+    "mkfs*",
+    "dd if=*",
+    "> /dev/*",
+    "chmod 777*",
+    "sudo*",
+    "curl*|*sh",
+    "wget*|*sh",  # Pipe to shell
+    "*; rm*",
+    "*&& rm*",  # Chained destructive
+]
+
+
+@dataclass
+class ToolPermission:
+    """Permission settings for a specific tool."""
+
+    level: PermissionLevel = PermissionLevel.ASK
+    allowed_patterns: list[str] = field(default_factory=list)
+    denied_patterns: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Permissions:
+    """Global permission settings."""
+
+    tools: dict[str, ToolPermission] = field(default_factory=dict)
+
+    # Session-only permissions (not persisted)
+    session_allowed: list[str] = field(default_factory=list)
+    session_denied: list[str] = field(default_factory=list)
+
+    @classmethod
+    def load(cls) -> "Permissions":
+        """Load permissions from config file."""
+        permissions = cls()
+
+        # Set defaults
+        permissions.tools = {
+            "shell": ToolPermission(
+                level=PermissionLevel.ASK,
+                allowed_patterns=SAFE_COMMANDS.copy(),
+                denied_patterns=DANGEROUS_PATTERNS.copy(),
+            ),
+            "filesystem": ToolPermission(level=PermissionLevel.ASK),
+            "search": ToolPermission(level=PermissionLevel.ALLOW),  # Search is safe
+        }
+
+        # Load from file if exists
+        if YAML_AVAILABLE and PERMISSIONS_FILE.exists():
+            try:
+                with open(PERMISSIONS_FILE) as f:
+                    data = yaml.safe_load(f) or {}
+
+                for tool_name, tool_data in data.get("tools", {}).items():
+                    if tool_name not in permissions.tools:
+                        permissions.tools[tool_name] = ToolPermission()
+
+                    perm = permissions.tools[tool_name]
+                    perm.level = PermissionLevel(tool_data.get("level", "ask"))
+                    perm.allowed_patterns = tool_data.get("allowed_patterns", perm.allowed_patterns)
+                    perm.denied_patterns = tool_data.get("denied_patterns", perm.denied_patterns)
+
+            except Exception:
+                pass  # Use defaults on error
+
+        return permissions
+
+    def save(self):
+        """Save permissions to config file."""
+        if not YAML_AVAILABLE:
+            return
+
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+        data = {"tools": {}}
+
+        for tool_name, perm in self.tools.items():
+            data["tools"][tool_name] = {
+                "level": perm.level.value,
+                "allowed_patterns": perm.allowed_patterns,
+                "denied_patterns": perm.denied_patterns,
+            }
+
+        with open(PERMISSIONS_FILE, "w") as f:
+            yaml.safe_dump(data, f, default_flow_style=False)
+
+    def check_permission(
+        self, tool_name: str, command: str | None = None
+    ) -> tuple[PermissionLevel, str | None]:
+        """
+        Check if a tool/command is allowed.
+
+        Returns:
+            (PermissionLevel, reason) - The permission level and optional reason
+        """
+        tool_perm = self.tools.get(tool_name, ToolPermission())
+
+        # Check session permissions first (for commands)
+        if command:
+            # Session denied takes priority
+            for pattern in self.session_denied:
+                if self._match_command(command, pattern):
+                    return PermissionLevel.DENY, f"Denied this session: {pattern}"
+
+            # Session allowed
+            for pattern in self.session_allowed:
+                if self._match_command(command, pattern):
+                    return PermissionLevel.ALLOW, f"Allowed this session: {pattern}"
+
+            # Check denied patterns (dangerous commands)
+            for pattern in tool_perm.denied_patterns:
+                if self._match_command(command, pattern):
+                    return PermissionLevel.DENY, f"Matches dangerous pattern: {pattern}"
+
+            # Check allowed patterns (safe commands)
+            for pattern in tool_perm.allowed_patterns:
+                if self._match_command(command, pattern):
+                    return PermissionLevel.ALLOW, f"Matches safe pattern: {pattern}"
+
+        # Fall back to tool-level permission
+        return tool_perm.level, None
+
+    def _match_command(self, command: str, pattern: str) -> bool:
+        """Check if a command matches a pattern."""
+        command = command.strip().lower()
+        pattern = pattern.strip().lower()
+
+        # Handle wildcard patterns
+        if "*" in pattern:
+            # Convert glob to regex
+            regex = fnmatch.translate(pattern)
+            return bool(re.match(regex, command))
+
+        # Exact match or prefix match
+        return command == pattern or command.startswith(pattern + " ")
+
+    def add_allowed_pattern(self, tool_name: str, pattern: str, session_only: bool = False):
+        """Add a pattern to the allowed list."""
+        if session_only:
+            if pattern not in self.session_allowed:
+                self.session_allowed.append(pattern)
+        else:
+            if tool_name not in self.tools:
+                self.tools[tool_name] = ToolPermission()
+            if pattern not in self.tools[tool_name].allowed_patterns:
+                self.tools[tool_name].allowed_patterns.append(pattern)
+                self.save()
+
+    def add_denied_pattern(self, tool_name: str, pattern: str, session_only: bool = False):
+        """Add a pattern to the denied list."""
+        if session_only:
+            if pattern not in self.session_denied:
+                self.session_denied.append(pattern)
+        else:
+            if tool_name not in self.tools:
+                self.tools[tool_name] = ToolPermission()
+            if pattern not in self.tools[tool_name].denied_patterns:
+                self.tools[tool_name].denied_patterns.append(pattern)
+                self.save()
+
+    def set_tool_permission(self, tool_name: str, level: PermissionLevel):
+        """Set the default permission level for a tool."""
+        if tool_name not in self.tools:
+            self.tools[tool_name] = ToolPermission()
+        self.tools[tool_name].level = level
+        self.save()
+
+    def clear_session_permissions(self):
+        """Clear session-only permissions."""
+        self.session_allowed.clear()
+        self.session_denied.clear()
+
+
+# Global permissions instance
+_permissions: Permissions | None = None
+
+
+def get_permissions() -> Permissions:
+    """Get the global permissions instance."""
+    global _permissions
+    if _permissions is None:
+        _permissions = Permissions.load()
+    return _permissions
+
+
+def reset_permissions():
+    """Reset permissions to defaults."""
+    global _permissions
+    _permissions = None
+    if PERMISSIONS_FILE.exists():
+        PERMISSIONS_FILE.unlink()

config/settings.py

@@ -0,0 +1,185 @@
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+try:
+    import yaml
+
+    YAML_AVAILABLE = True
+except ImportError:
+    YAML_AVAILABLE = False
+
+try:
+    import keyring
+
+    KEYRING_AVAILABLE = True
+except ImportError:
+    KEYRING_AVAILABLE = False
+
+CONFIG_DIR = Path.home() / ".devorch"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+KEYRING_SERVICE = "devorch"
+
+
+@dataclass
+class ProviderConfig:
+    api_key: str | None = None
+    default_model: str = ""
+    base_url: str | None = None
+    key_encrypted: bool = False  # True if key is stored in keyring
+
+
+@dataclass
+class Settings:
+    default_provider: str = "openai"
+    providers: dict[str, ProviderConfig] = field(default_factory=dict)
+
+    @classmethod
+    def load(cls) -> "Settings":
+        """Load settings from config file, keyring, and env vars."""
+        settings = cls()
+
+        # Load from YAML if exists and yaml is available
+        if YAML_AVAILABLE and CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE) as f:
+                    data = yaml.safe_load(f) or {}
+                settings.default_provider = data.get("default_provider", "openai")
+                for name, config in data.get("providers", {}).items():
+                    settings.providers[name] = ProviderConfig(**config)
+            except Exception:
+                pass  # Fall back to defaults if config is invalid
+
+        # Environment variable mappings: (env_var_name, default_model)
+        env_mappings = {
+            "openai": ("OPENAI_API_KEY", "gpt-4o"),
+            "anthropic": ("ANTHROPIC_API_KEY", "claude-sonnet-4-20250514"),
+            "gemini": ("GOOGLE_API_KEY", "gemini-1.5-pro"),
+            "local": (None, "llama3"),
+            "groq": ("GROQ_API_KEY", "llama-3.1-70b-versatile"),
+            "openrouter": ("OPENROUTER_API_KEY", "openai/gpt-4o"),
+            "mistral": ("MISTRAL_API_KEY", "mistral-large-latest"),
+            "together": ("TOGETHER_API_KEY", "meta-llama/Llama-3-70b-chat-hf"),
+            "lmstudio": (None, ""),
+            "github_copilot": ("GITHUB_TOKEN", "gpt-4o"),
+            "deepseek": ("DEEPSEEK_API_KEY", "deepseek-chat"),
+            "kimi": ("MOONSHOT_API_KEY", "moonshot-v1-32k"),
+            "custom": ("CUSTOM_API_KEY", ""),
+        }
+
+        for provider, (env_var, default_model) in env_mappings.items():
+            if provider not in settings.providers:
+                settings.providers[provider] = ProviderConfig(default_model=default_model)
+
+            # Set default model if not configured
+            if not settings.providers[provider].default_model:
+                settings.providers[provider].default_model = default_model
+
+            # Priority: 1. Keyring, 2. Env var, 3. Config file
+            # Try keyring first (encrypted storage)
+            if KEYRING_AVAILABLE and not settings.providers[provider].api_key:
+                try:
+                    key = keyring.get_password(KEYRING_SERVICE, provider)
+                    if key:
+                        settings.providers[provider].api_key = key
+                        settings.providers[provider].key_encrypted = True
+                except Exception:
+                    pass  # Keyring not available or failed
+
+            # Override with environment variable if present
+            if env_var and os.environ.get(env_var):
+                settings.providers[provider].api_key = os.environ[env_var]
+                settings.providers[provider].key_encrypted = False
+
+        # Set default base_url for local provider
+        if "local" in settings.providers and not settings.providers["local"].base_url:
+            settings.providers["local"].base_url = "http://localhost:11434/v1"
+
+        return settings
+
+    def get_api_key(self, provider: str) -> str | None:
+        """Get API key for a provider."""
+        config = self.providers.get(provider)
+        return config.api_key if config else None
+
+    def get_default_model(self, provider: str) -> str:
+        """Get default model for a provider."""
+        config = self.providers.get(provider)
+        return config.default_model if config else ""
+
+    def get_base_url(self, provider: str) -> str | None:
+        """Get base URL for a provider (used for local/custom endpoints)."""
+        config = self.providers.get(provider)
+        return config.base_url if config else None
+
+    def is_key_encrypted(self, provider: str) -> bool:
+        """Check if the API key is stored encrypted."""
+        config = self.providers.get(provider)
+        return config.key_encrypted if config else False
+
+
+def ensure_config_dir():
+    """Create config directory if it doesn't exist."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def set_api_key(provider: str, api_key: str) -> bool:
+    """
+    Store an API key securely using keyring.
+    Returns True if stored encrypted, False if keyring unavailable.
+    """
+    if not KEYRING_AVAILABLE:
+        return False
+
+    try:
+        keyring.set_password(KEYRING_SERVICE, provider, api_key)
+        return True
+    except Exception:
+        return False
+
+
+def delete_api_key(provider: str) -> bool:
+    """Delete an API key from keyring."""
+    if not KEYRING_AVAILABLE:
+        return False
+
+    try:
+        keyring.delete_password(KEYRING_SERVICE, provider)
+        return True
+    except Exception:
+        return False
+
+
+def save_config(settings: Settings):
+    """Save settings to config file (excluding API keys - those go in keyring)."""
+    if not YAML_AVAILABLE:
+        raise RuntimeError("PyYAML is required to save config. Install with: pip install pyyaml")
+
+    ensure_config_dir()
+
+    data = {"default_provider": settings.default_provider, "providers": {}}
+
+    for name, config in settings.providers.items():
+        provider_data = {}
+        # Don't save API keys to file - they should be in keyring or env vars
+        if config.default_model:
+            provider_data["default_model"] = config.default_model
+        if config.base_url:
+            provider_data["base_url"] = config.base_url
+        if provider_data:
+            data["providers"][name] = provider_data
+
+    with open(CONFIG_FILE, "w") as f:
+        yaml.safe_dump(data, f, default_flow_style=False)
+
+
+def keyring_available() -> bool:
+    """Check if keyring is available and working."""
+    if not KEYRING_AVAILABLE:
+        return False
+    try:
+        # Try a test operation
+        keyring.get_password(KEYRING_SERVICE, "__test__")
+        return True
+    except Exception:
+        return False