smart-tree 8.0.0

//! Permissions - Work by default, deny when necessary
//!
//! Philosophy: Enable people, don't block them.
//! Instead of whitelisting what users CAN do, we only specify
//! what they CAN'T do (deny patterns).

use serde::{Deserialize, Serialize};
use std::path::Path;

/// Access level for a collaborator
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Default)]
pub enum AccessLevel {
    /// No access
    None,
    /// Can view files and run read-only tools
    #[default]
    Read,
    /// Can edit files in their space
    Write,
    /// Can manage other collaborators, settings
    Admin,
    /// Project owner - full control
    Owner,
}

/// A specific permission grant or deny
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Permission {
    /// What action (read, write, execute, admin)
    pub action: PermissionAction,
    /// Path pattern (glob) this applies to
    pub path_pattern: Option<String>,
    /// Whether this is a grant or deny
    pub effect: PermissionEffect,
}

/// Permission action types
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum PermissionAction {
    /// Read files
    Read,
    /// Write/edit files
    Write,
    /// Execute commands
    Execute,
    /// Run specific tools
    Tool(String),
    /// Administrative actions
    Admin,
    /// All actions
    All,
}

/// Grant or deny
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum PermissionEffect {
    /// Allow this action (rarely needed - work by default)
    Allow,
    /// Deny this action (primary mechanism)
    Deny,
}

/// Project access configuration
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ProjectAccess {
    /// Default access level for new collaborators
    pub default_level: AccessLevel,

    /// Specific deny rules (work by default, deny specific things)
    pub deny_rules: Vec<Permission>,

    /// Paths that are always off-limits (secrets, credentials)
    pub protected_paths: Vec<String>,

    /// Tools that require explicit approval
    pub restricted_tools: Vec<String>,
}

impl ProjectAccess {
    /// Create with sensible defaults
    pub fn new() -> Self {
        ProjectAccess {
            default_level: AccessLevel::Write,
            deny_rules: Vec::new(),
            protected_paths: vec![
                ".env".to_string(),
                ".env.*".to_string(),
                "**/secrets/**".to_string(),
                "**/*.pem".to_string(),
                "**/*.key".to_string(),
                "**/credentials*".to_string(),
            ],
            restricted_tools: vec![
                "execute_command".to_string(), // Needs approval
            ],
        }
    }

    /// Check if a path is accessible
    pub fn can_access_path(&self, path: &Path, level: &AccessLevel) -> bool {
        // Owner can access everything
        if *level == AccessLevel::Owner {
            return true;
        }

        let path_str = path.to_string_lossy();

        // Check protected paths
        for pattern in &self.protected_paths {
            if Self::matches_glob(pattern, &path_str) {
                return false;
            }
        }

        // Check deny rules
        for rule in &self.deny_rules {
            if rule.effect == PermissionEffect::Deny {
                if let Some(ref pattern) = rule.path_pattern {
                    if Self::matches_glob(pattern, &path_str) {
                        return false;
                    }
                }
            }
        }

        true
    }

    /// Check if a tool can be used
    pub fn can_use_tool(&self, tool: &str, level: &AccessLevel) -> bool {
        // Owner/Admin can use all tools
        if *level >= AccessLevel::Admin {
            return true;
        }

        // Check if tool is restricted
        !self.restricted_tools.contains(&tool.to_string())
    }

    /// Simple glob matching (supports * and **)
    fn matches_glob(pattern: &str, path: &str) -> bool {
        // Simple implementation - could use glob crate for full support
        if pattern.contains("**") {
            // ** matches any path segments
            let parts: Vec<&str> = pattern.split("**").collect();
            if parts.len() == 2 {
                let prefix = parts[0].trim_end_matches('/');
                let suffix = parts[1].trim_start_matches('/');

                // Empty prefix means match from start
                let prefix_ok = prefix.is_empty() || path.starts_with(prefix);

                // For suffix, need to handle *.ext patterns
                let suffix_ok = if suffix.is_empty() {
                    true
                } else if suffix.starts_with('*') {
                    // Handle *.ext pattern in suffix
                    let ext = suffix.trim_start_matches('*');
                    path.ends_with(ext)
                } else {
                    path.ends_with(suffix)
                };

                return prefix_ok && suffix_ok;
            }
        }

        // Simple * matching
        if pattern.contains('*') && !pattern.contains("**") {
            let parts: Vec<&str> = pattern.split('*').collect();
            if parts.len() == 2 {
                return path.starts_with(parts[0]) && path.ends_with(parts[1]);
            }
        }

        // Exact match
        pattern == path
    }

    /// Add a deny rule
    pub fn deny(&mut self, action: PermissionAction, path_pattern: Option<&str>) {
        self.deny_rules.push(Permission {
            action,
            path_pattern: path_pattern.map(String::from),
            effect: PermissionEffect::Deny,
        });
    }

    /// Protect a path pattern
    pub fn protect_path(&mut self, pattern: &str) {
        self.protected_paths.push(pattern.to_string());
    }

    /// Restrict a tool (require approval)
    pub fn restrict_tool(&mut self, tool: &str) {
        if !self.restricted_tools.contains(&tool.to_string()) {
            self.restricted_tools.push(tool.to_string());
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_access() {
        let access = ProjectAccess::new();
        assert_eq!(access.default_level, AccessLevel::Write);
    }

    #[test]
    fn test_protected_paths() {
        let access = ProjectAccess::new();
        let level = AccessLevel::Write;

        // Should deny access to .env files
        assert!(!access.can_access_path(Path::new(".env"), &level));
        assert!(!access.can_access_path(Path::new(".env.production"), &level));

        // Should allow normal files
        assert!(access.can_access_path(Path::new("src/main.rs"), &level));
    }

    #[test]
    fn test_owner_bypasses_all() {
        let access = ProjectAccess::new();
        let level = AccessLevel::Owner;

        // Owner can access protected paths
        assert!(access.can_access_path(Path::new(".env"), &level));
        assert!(access.can_access_path(Path::new("secrets/api.key"), &level));
    }

    #[test]
    fn test_glob_matching() {
        assert!(ProjectAccess::matches_glob("*.rs", "main.rs"));
        assert!(ProjectAccess::matches_glob("**/*.key", "secrets/api.key"));
        assert!(ProjectAccess::matches_glob(".env.*", ".env.production"));
        assert!(!ProjectAccess::matches_glob("*.rs", "main.py"));
    }
}