xenfra 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

xenfra/utils/errors.py

@@ -1,116 +1,116 @@
-"""Human-friendly error messages with actionable solutions."""
-
-from rich.console import Console
-
-console = Console()
-
-
-ERROR_SOLUTIONS = {
-    "port_in_use": {
-        "message": "Port {port} is already in use on the droplet",
-        "solution": "Change the port in xenfra.yaml or stop the conflicting service",
-        "command": "ssh root@{{ip}} 'lsof -i :{port}'  # Find process using port",
-    },
-    "missing_dependency": {
-        "message": "Missing dependency: {package}",
-        "solution": "Add {package} to dependencies in {file}",
-        "command": "uv add {package}  # OR: echo '{package}' >> requirements.txt",
-    },
-    "ssh_failure": {
-        "message": "Cannot connect to droplet via SSH",
-        "solution": "Check firewall rules, wait for droplet boot, or verify SSH keys",
-        "command": "ssh -v root@{ip}  # Verbose SSH for debugging",
-    },
-    "docker_build_failed": {
-        "message": "Docker build failed",
-        "solution": "Check Dockerfile syntax and base image availability",
-        "command": "docker build . --no-cache  # Test locally",
-    },
-    "health_check_failed": {
-        "message": "Application failed health check",
-        "solution": "Ensure your app responds on port {port} at /health or /",
-        "command": "curl http://{{ip}}:{port}/health",
-    },
-    "out_of_memory": {
-        "message": "Container out of memory",
-        "solution": "Upgrade to a larger instance size in xenfra.yaml",
-        "command": "docker stats  # Check memory usage",
-    },
-}
-
-
-def show_error_with_solution(error_type: str, **kwargs) -> None:
-    """
-    Display error with actionable solution.
-    
-    Args:
-        error_type: Key from ERROR_SOLUTIONS
-        **kwargs: Template variables (port, ip, package, file, etc.)
-    """
-    error = ERROR_SOLUTIONS.get(error_type)
-    
-    if not error:
-        # Fallback for unknown errors
-        console.print(f"[red]❌ Error: {error_type}[/red]")
-        return
-    
-    # Format message with provided kwargs
-    try:
-        message = error["message"].format(**kwargs)
-        solution = error["solution"].format(**kwargs)
-        command = error.get("command", "").format(**kwargs)
-    except KeyError as e:
-        console.print(f"[red]❌ Error formatting message: missing {e}[/red]")
-        return
-    
-    console.print()
-    console.print(f"[red]❌ {message}[/red]")
-    console.print(f"[yellow]💡 Solution: {solution}[/yellow]")
-    
-    if command:
-        console.print(f"[dim]Try: {command}[/dim]")
-    console.print()
-
-
-def detect_error_type(error_message: str) -> tuple[str, dict]:
-    """
-    Attempt to detect error type from message.
-    
-    Returns:
-        (error_type, kwargs) for show_error_with_solution()
-    """
-    error_lower = error_message.lower()
-    
-    # Port detection
-    if "port" in error_lower and ("in use" in error_lower or "already" in error_lower):
-        # Try to extract port number
-        import re
-        port_match = re.search(r"port\s+(\d+)", error_lower)
-        port = port_match.group(1) if port_match else "8000"
-        return "port_in_use", {"port": port}
-    
-    # SSH detection
-    if "ssh" in error_lower or "connection refused" in error_lower:
-        return "ssh_failure", {"ip": "DROPLET_IP"}
-    
-    # Docker detection
-    if "docker" in error_lower and "build" in error_lower:
-        return "docker_build_failed", {}
-    
-    # Health check detection
-    if "health" in error_lower and ("fail" in error_lower or "timeout" in error_lower):
-        return "health_check_failed", {"port": "8000"}
-    
-    # Memory detection
-    if "memory" in error_lower or "oom" in error_lower:
-        return "out_of_memory", {}
-    
-    # Module not found
-    if "modulenotfounderror" in error_lower or "no module named" in error_lower:
-        import re
-        module_match = re.search(r"no module named ['\"]([^'\"]+)['\"]", error_lower)
-        package = module_match.group(1) if module_match else "PACKAGE_NAME"
-        return "missing_dependency", {"package": package, "file": "pyproject.toml"}
-    
-    # Unknown
-    return None, {}
+"""Human-friendly error messages with actionable solutions."""
+
+from rich.console import Console
+
+console = Console()
+
+
+ERROR_SOLUTIONS = {
+    "port_in_use": {
+        "message": "Port {port} is already in use on the droplet",
+        "solution": "Change the port in xenfra.yaml or stop the conflicting service",
+        "command": "ssh root@{{ip}} 'lsof -i :{port}'  # Find process using port",
+    },
+    "missing_dependency": {
+        "message": "Missing dependency: {package}",
+        "solution": "Add {package} to dependencies in {file}",
+        "command": "uv add {package}  # OR: echo '{package}' >> requirements.txt",
+    },
+    "ssh_failure": {
+        "message": "Cannot connect to droplet via SSH",
+        "solution": "Check firewall rules, wait for droplet boot, or verify SSH keys",
+        "command": "ssh -v root@{ip}  # Verbose SSH for debugging",
+    },
+    "docker_build_failed": {
+        "message": "Docker build failed",
+        "solution": "Check Dockerfile syntax and base image availability",
+        "command": "docker build . --no-cache  # Test locally",
+    },
+    "health_check_failed": {
+        "message": "Application failed health check",
+        "solution": "Ensure your app responds on port {port} at /health or /",
+        "command": "curl http://{{ip}}:{port}/health",
+    },
+    "out_of_memory": {
+        "message": "Container out of memory",
+        "solution": "Upgrade to a larger instance size in xenfra.yaml",
+        "command": "docker stats  # Check memory usage",
+    },
+}
+
+
+def show_error_with_solution(error_type: str, **kwargs) -> None:
+    """
+    Display error with actionable solution.
+    
+    Args:
+        error_type: Key from ERROR_SOLUTIONS
+        **kwargs: Template variables (port, ip, package, file, etc.)
+    """
+    error = ERROR_SOLUTIONS.get(error_type)
+    
+    if not error:
+        # Fallback for unknown errors
+        console.print(f"[red]❌ Error: {error_type}[/red]")
+        return
+    
+    # Format message with provided kwargs
+    try:
+        message = error["message"].format(**kwargs)
+        solution = error["solution"].format(**kwargs)
+        command = error.get("command", "").format(**kwargs)
+    except KeyError as e:
+        console.print(f"[red]❌ Error formatting message: missing {e}[/red]")
+        return
+    
+    console.print()
+    console.print(f"[red]❌ {message}[/red]")
+    console.print(f"[yellow]💡 Solution: {solution}[/yellow]")
+    
+    if command:
+        console.print(f"[dim]Try: {command}[/dim]")
+    console.print()
+
+
+def detect_error_type(error_message: str) -> tuple[str, dict]:
+    """
+    Attempt to detect error type from message.
+    
+    Returns:
+        (error_type, kwargs) for show_error_with_solution()
+    """
+    error_lower = error_message.lower()
+    
+    # Port detection
+    if "port" in error_lower and ("in use" in error_lower or "already" in error_lower):
+        # Try to extract port number
+        import re
+        port_match = re.search(r"port\s+(\d+)", error_lower)
+        port = port_match.group(1) if port_match else "8000"
+        return "port_in_use", {"port": port}
+    
+    # SSH detection
+    if "ssh" in error_lower or "connection refused" in error_lower:
+        return "ssh_failure", {"ip": "DROPLET_IP"}
+    
+    # Docker detection
+    if "docker" in error_lower and "build" in error_lower:
+        return "docker_build_failed", {}
+    
+    # Health check detection
+    if "health" in error_lower and ("fail" in error_lower or "timeout" in error_lower):
+        return "health_check_failed", {"port": "8000"}
+    
+    # Memory detection
+    if "memory" in error_lower or "oom" in error_lower:
+        return "out_of_memory", {}
+    
+    # Module not found
+    if "modulenotfounderror" in error_lower or "no module named" in error_lower:
+        import re
+        module_match = re.search(r"no module named ['\"]([^'\"]+)['\"]", error_lower)
+        package = module_match.group(1) if module_match else "PACKAGE_NAME"
+        return "missing_dependency", {"package": package, "file": "pyproject.toml"}
+    
+    # Unknown
+    return None, {}

xenfra/utils/file_sync.py

@@ -0,0 +1,286 @@
+"""
+File synchronization utilities for delta uploads.
+
+Provides functions to scan project files, compute SHA256 hashes,
+and manage local file caches for incremental deployments.
+"""
+
+import hashlib
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+# Patterns to exclude from deployment
+EXCLUDE_PATTERNS: Set[str] = {
+    # Version control
+    '.git',
+    '.svn',
+    '.hg',
+    
+    # Python
+    '.venv',
+    'venv',
+    '__pycache__',
+    '*.pyc',
+    '*.pyo',
+    '.pytest_cache',
+    '.mypy_cache',
+    '*.egg-info',
+    'dist',
+    'build',
+    
+    # Node.js
+    'node_modules',
+    
+    # IDE/Editor
+    '.idea',
+    '.vscode',
+    '*.swp',
+    
+    # Xenfra
+    '.xenfra',
+    
+    # Environment
+    '.env',
+    '.env.local',
+    '.env.*.local',
+    
+    # OS
+    '.DS_Store',
+    'Thumbs.db',
+}
+
+# File extensions to always exclude
+EXCLUDE_EXTENSIONS: Set[str] = {
+    '.pyc', '.pyo', '.so', '.dylib', '.dll',
+    '.exe', '.bin', '.obj', '.o',
+}
+
+
+def should_exclude(path: Path, root: Path) -> bool:
+    """Check if a path should be excluded from upload."""
+    rel_parts = path.relative_to(root).parts
+    
+    # Check each part of the path against exclusion patterns
+    for part in rel_parts:
+        if part in EXCLUDE_PATTERNS:
+            return True
+        # Check wildcard patterns
+        for pattern in EXCLUDE_PATTERNS:
+            if pattern.startswith('*') and part.endswith(pattern[1:]):
+                return True
+    
+    # Check file extension
+    if path.suffix.lower() in EXCLUDE_EXTENSIONS:
+        return True
+    
+    return False
+
+
+def compute_file_sha(filepath: str) -> str:
+    """Compute SHA256 hash of a file's content."""
+    sha256 = hashlib.sha256()
+    with open(filepath, 'rb') as f:
+        for chunk in iter(lambda: f.read(8192), b''):
+            sha256.update(chunk)
+    return sha256.hexdigest()
+
+
+def scan_project_files(root: str = '.') -> List[Dict]:
+    """
+    Scan project directory and return list of files with their metadata.
+    
+    Returns:
+        List of dicts with keys: path, sha, size, abs_path
+    """
+    files = []
+    root_path = Path(root).resolve()
+    
+    for filepath in root_path.rglob('*'):
+        # Skip directories
+        if not filepath.is_file():
+            continue
+        
+        # Check exclusions
+        if should_exclude(filepath, root_path):
+            continue
+        
+        # Skip very large files (> 50MB)
+        file_size = filepath.stat().st_size
+        if file_size > 50 * 1024 * 1024:
+            continue
+        
+        # Normalize path to use forward slashes
+        rel_path = str(filepath.relative_to(root_path)).replace('\\', '/')
+        
+        files.append({
+            'path': rel_path,
+            'sha': compute_file_sha(str(filepath)),
+            'size': file_size,
+            'abs_path': str(filepath),
+        })
+    
+    return files
+
+
+def get_xenfra_dir(project_root: str = '.') -> Path:
+    """Get or create the .xenfra directory."""
+    xenfra_dir = Path(project_root).resolve() / '.xenfra'
+    xenfra_dir.mkdir(exist_ok=True)
+    
+    # Create cache subdirectory
+    cache_dir = xenfra_dir / 'cache'
+    cache_dir.mkdir(exist_ok=True)
+    
+    return xenfra_dir
+
+
+def load_file_cache(project_root: str = '.') -> Dict[str, Dict]:
+    """
+    Load cached file hashes from .xenfra/cache/file_hashes.json.
+    
+    Returns:
+        Dict mapping file paths to {sha, mtime, size}
+    """
+    xenfra_dir = get_xenfra_dir(project_root)
+    cache_file = xenfra_dir / 'cache' / 'file_hashes.json'
+    
+    if cache_file.exists():
+        try:
+            with open(cache_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+    return {}
+
+
+def save_file_cache(cache: Dict[str, Dict], project_root: str = '.'):
+    """Save file hashes to .xenfra/cache/file_hashes.json."""
+    xenfra_dir = get_xenfra_dir(project_root)
+    cache_file = xenfra_dir / 'cache' / 'file_hashes.json'
+    
+    with open(cache_file, 'w') as f:
+        json.dump(cache, f, indent=2)
+
+
+def scan_project_files_cached(root: str = '.') -> List[Dict]:
+    """
+    Scan project files using local cache for unchanged files.
+    
+    Only recomputes SHA for files whose mtime or size changed.
+    This is much faster for large projects with few changes.
+    """
+    files = []
+    root_path = Path(root).resolve()
+    cache = load_file_cache(root)
+    new_cache = {}
+    
+    for filepath in root_path.rglob('*'):
+        if not filepath.is_file():
+            continue
+        
+        if should_exclude(filepath, root_path):
+            continue
+        
+        file_size = filepath.stat().st_size
+        if file_size > 50 * 1024 * 1024:
+            continue
+        
+        rel_path = str(filepath.relative_to(root_path)).replace('\\', '/')
+        mtime = filepath.stat().st_mtime
+        
+        # Check if we can use cached value
+        cached = cache.get(rel_path)
+        if cached and cached.get('mtime') == mtime and cached.get('size') == file_size:
+            sha = cached['sha']
+        else:
+            # File changed, recompute SHA
+            sha = compute_file_sha(str(filepath))
+        
+        # Update cache
+        new_cache[rel_path] = {
+            'sha': sha,
+            'mtime': mtime,
+            'size': file_size,
+        }
+        
+        files.append({
+            'path': rel_path,
+            'sha': sha,
+            'size': file_size,
+            'abs_path': str(filepath),
+        })
+    
+    # Save updated cache
+    save_file_cache(new_cache, root)
+    
+    return files
+
+
+def load_project_config(project_root: str = '.') -> Optional[Dict]:
+    """Load .xenfra/config.json if it exists."""
+    xenfra_dir = Path(project_root).resolve() / '.xenfra'
+    config_file = xenfra_dir / 'config.json'
+    
+    if config_file.exists():
+        try:
+            with open(config_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return None
+    return None
+
+
+def ensure_gitignore_ignored(project_root: str = '.'):
+    """Ensure .xenfra/ is in the .gitignore file."""
+    root_path = Path(project_root).resolve()
+    gitignore_path = root_path / '.gitignore'
+    
+    entry = '.xenfra/\n'
+    
+    if not gitignore_path.exists():
+        try:
+            with open(gitignore_path, 'w') as f:
+                f.write(entry)
+            return True
+        except IOError:
+            return False
+            
+    try:
+        with open(gitignore_path, 'r') as f:
+            content = f.read()
+            
+        if '.xenfra/' not in content and '.xenfra' not in content:
+            with open(gitignore_path, 'a') as f:
+                if not content.endswith('\n'):
+                    f.write('\n')
+                f.write(entry)
+            return True
+    except IOError:
+        return False
+    
+    return False
+
+
+def save_project_config(config: Dict, project_root: str = '.'):
+    """Save project config to .xenfra/config.json."""
+    xenfra_dir = get_xenfra_dir(project_root)
+    config_file = xenfra_dir / 'config.json'
+    
+    with open(config_file, 'w') as f:
+        json.dump(config, f, indent=2)
+
+
+def update_last_deployment(deployment_id: str, url: str = None, project_root: str = '.'):
+    """Update the last deployment info in project config."""
+    config = load_project_config(project_root) or {}
+    
+    config['lastDeployment'] = {
+        'id': deployment_id,
+        'url': url,
+        'createdAt': datetime.utcnow().isoformat() + 'Z',
+    }
+    
+    save_project_config(config, project_root)