xenfra 0.4.2__tar.gz → 0.4.3__tar.gz

{xenfra-0.4.2 → xenfra-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: xenfra
-Version: 0.4.2
+Version: 0.4.3
 Summary: A 'Zen Mode' infrastructure engine for Python developers.
 Author: xenfra-cloud
 Author-email: xenfra-cloud <xenfracloud@gmail.com>

{xenfra-0.4.2 → xenfra-0.4.3}/pyproject.toml

@@ -1,56 +1,56 @@
-[project]
-name = "xenfra"
-version = "0.4.2"
-description = "A 'Zen Mode' infrastructure engine for Python developers."
-readme = "README.md"
-authors = [
-    { name = "xenfra-cloud", email = "xenfracloud@gmail.com" }
-]
-
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-    "Development Status :: 3 - Alpha",
-    "Intended Audience :: Developers",
-    "Topic :: Software Development :: Build Tools",
-    "Topic :: System :: Systems Administration",
-]
-
-dependencies = [
-    "click>=8.1.7",
-    "rich>=14.2.0",
-    "sqlmodel>=0.0.16",
-    "python-digitalocean>=1.17.0",
-    "python-dotenv>=1.2.1",
-    "pyyaml>=6.0.1",
-    "fabric>=3.2.2",
-    "xenfra-sdk",
-    "httpx>=0.27.0",
-    "keyring>=25.7.0",
-    "keyrings.alt>=5.0.2",
-    "tenacity>=8.2.3", # For retry logic
-    "cryptography>=43.0.0", # For encrypted file-based token storage
-    "toml>=0.10.2",
-]
-requires-python = ">=3.13"
-
-[tool.uv.sources]
-xenfra-sdk = { workspace = true }
-
-[project.urls]
-Homepage = "https://github.com/xenfra-cloud/xenfra"
-Issues = "https://github.com/xenfra-cloud/xenfra/issues"
-
-[project.optional-dependencies]
-test = [
-    "pytest>=8.0.0",
-    "pytest-mock>=3.12.0",
-]
-
-[project.scripts]
-xenfra = "xenfra.main:main"
-
-[build-system]
-requires = ["uv_build>=0.9.18,<0.10.0"]
-build-backend = "uv_build"
+[project]
+name = "xenfra"
+version = "0.4.3"
+description = "A 'Zen Mode' infrastructure engine for Python developers."
+readme = "README.md"
+authors = [
+    { name = "xenfra-cloud", email = "xenfracloud@gmail.com" }
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: System :: Systems Administration",
+]
+
+dependencies = [
+    "click>=8.1.7",
+    "rich>=14.2.0",
+    "sqlmodel>=0.0.16",
+    "python-digitalocean>=1.17.0",
+    "python-dotenv>=1.2.1",
+    "pyyaml>=6.0.1",
+    "fabric>=3.2.2",
+    "xenfra-sdk",
+    "httpx>=0.27.0",
+    "keyring>=25.7.0",
+    "keyrings.alt>=5.0.2",
+    "tenacity>=8.2.3", # For retry logic
+    "cryptography>=43.0.0", # For encrypted file-based token storage
+    "toml>=0.10.2",
+]
+requires-python = ">=3.13"
+
+[tool.uv.sources]
+xenfra-sdk = { workspace = true }
+
+[project.urls]
+Homepage = "https://github.com/xenfra-cloud/xenfra"
+Issues = "https://github.com/xenfra-cloud/xenfra/issues"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.0.0",
+    "pytest-mock>=3.12.0",
+]
+
+[project.scripts]
+xenfra = "xenfra.main:main"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"

{xenfra-0.4.2 → xenfra-0.4.3}/src/xenfra/commands/deployments.py

@@ -65,7 +65,7 @@ def show_patch_preview(patch_data: dict):
     console.print()
 
 
-def _stream_deployment(client: XenfraClient, project_name: str, git_repo: str, branch: str, framework: str, region: str, size_slug: str, is_dockerized: bool = True, port: int = None, command: str = None, database: str = None):
+def _stream_deployment(client: XenfraClient, project_name: str, git_repo: str, branch: str, framework: str, region: str, size_slug: str, is_dockerized: bool = True, port: int = None, command: str = None, entrypoint: str = None, database: str = None, package_manager: str = None, dependency_file: str = None, file_manifest: list = None):
     """
     Creates deployment with real-time SSE streaming (no polling needed).
 
@@ -93,8 +93,13 @@ def _stream_deployment(client: XenfraClient, project_name: str, git_repo: str, b
             is_dockerized=is_dockerized,
             port=port,
             command=command,
+            entrypoint=entrypoint,  # Pass entrypoint to deployment API
             database=database,
+            package_manager=package_manager,
+            dependency_file=dependency_file,
+            file_manifest=file_manifest,
         ):
+
             event_type = event.get("event", "message")
             data = event.get("data", "")
 
@@ -359,6 +364,8 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal):
     # Resolve values with precedence: 1. CLI Flag, 2. xenfra.yaml, 3. Default
     project_name = project_name or config.get("name") or os.path.basename(os.getcwd())
     framework = framework or config.get("framework")
+    # Track if is_dockerized was explicitly set in config (to avoid AI override)
+    is_dockerized_from_config = "is_dockerized" in config
     is_dockerized = config.get("is_dockerized", True)
     region = region or config.get("region") or "nyc3"
     
@@ -379,10 +386,15 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal):
                 size = "s-1vcpu-1gb"
 
     # Extract port, command, database from config
-    port = config.get("port", 8000)
+    # Track if port was explicitly set to avoid AI override
+    port_from_config = config.get("port")
+    port = port_from_config or 8000
     command = config.get("command")  # Auto-detected if not provided
+    entrypoint = config.get("entrypoint")  # e.g., "todo.main:app"
     database_config = config.get("database", {})
     database = database_config.get("type") if isinstance(database_config, dict) else None
+    package_manager = config.get("package_manager", "pip")
+    dependency_file = config.get("dependency_file", "requirements.txt")
 
     # Default project name to current directory
     if not project_name:
@@ -403,9 +415,10 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal):
         console.print(f"[cyan]Deploying {project_name} from git repository...[/cyan]")
         console.print(f"[dim]Repository: {git_repo} (branch: {branch})[/dim]")
     else:
-        console.print(f"[cyan]Deploying {project_name} from local directory...[/cyan]")
-        console.print("[dim]Code will be uploaded to the droplet[/dim]")
-        # Note: SDK's InfraEngine handles local upload via fabric.transfer.Upload()
+        # Note: Local folder deployment only works when engine runs locally
+        # In cloud API mode, this will fail with a clear error from the server
+        console.print(f"[cyan]Deploying {project_name}...[/cyan]")
+        console.print("[dim]Note: Git repository recommended for cloud deployments[/dim]")
 
     # Validate branch name
     is_valid, error_msg = validate_branch_name(branch)
@@ -427,10 +440,6 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal):
     try:
         with get_client() as client:
             while attempt < MAX_RETRY_ATTEMPTS:
-                # Safety check to prevent infinite loops
-                if attempt > MAX_RETRY_ATTEMPTS:
-                    raise RuntimeError("Safety break: Retry loop exceeded MAX_RETRY_ATTEMPTS.")
-
                 attempt += 1
 
                 if attempt > 1:
@@ -449,13 +458,18 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal):
                         if code_snippets:
                             analysis = client.intelligence.analyze_codebase(code_snippets)
                             framework = analysis.framework
-                            is_dockerized = analysis.is_dockerized
+                            # Only use AI's is_dockerized if config didn't explicitly set it
+                            if not is_dockerized_from_config:
+                                is_dockerized = analysis.is_dockerized
+                            # Override port if AI detected it and config didn't set one
+                            if not port_from_config and analysis.port:
+                                port = analysis.port
                             # Override port and size if AI has strong recommendations
                             if not size and analysis.instance_size:
                                 size = "s-1vcpu-1gb" if analysis.instance_size == "basic" else "s-2vcpu-4gb"
                             
                             mode_str = "Docker" if is_dockerized else "Bare Metal"
-                            console.print(f"[green]✓ Detected {framework.upper()} project ({mode_str} Mode)[/green] (Port: {analysis.port})")
+                            console.print(f"[green]✓ Detected {framework.upper()} project ({mode_str} Mode)[/green] (Port: {port})")
                         else:
                             console.print("[yellow]⚠ No code files found for AI analysis. Defaulting to 'fastapi'[/yellow]")
                             framework = "fastapi"
@@ -465,6 +479,48 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal):
                         framework = "fastapi"
                         is_dockerized = True
 
+                # Delta upload: if no git_repo, scan and upload local files
+                file_manifest = None
+                if not git_repo:
+                    from ..utils.file_sync import scan_project_files_cached, ensure_gitignore_ignored
+                    
+                    # Protect privacy: ensure .xenfra is in .gitignore
+                    if ensure_gitignore_ignored():
+                        console.print("[dim]   - Added .xenfra to .gitignore for privacy[/dim]")
+                    
+                    console.print("[cyan]📁 Scanning project files...[/cyan]")
+
+                    file_manifest = scan_project_files_cached()
+                    console.print(f"[dim]Found {len(file_manifest)} files[/dim]")
+                    
+                    if not file_manifest:
+                        console.print("[bold red]Error: No files found to deploy.[/bold red]")
+                        raise click.Abort()
+                    
+                    # Check which files need uploading
+                    console.print("[cyan]🔍 Checking file cache...[/cyan]")
+                    check_result = client.files.check(file_manifest)
+                    missing = check_result.get('missing', [])
+                    cached = check_result.get('cached', 0)
+                    
+                    if cached > 0:
+                        console.print(f"[green]✓ {cached} files already cached[/green]")
+                    
+                    # Upload missing files
+                    if missing:
+                        console.print(f"[cyan]☁️ Uploading {len(missing)} files...[/cyan]")
+                        uploaded = client.files.upload_files(
+                            file_manifest,
+                            missing,
+                            progress_callback=lambda done, total: console.print(f"[dim]   Progress: {done}/{total}[/dim]") if done % 10 == 0 or done == total else None
+                        )
+                        console.print(f"[green]✓ Uploaded {uploaded} files[/green]")
+                    else:
+                        console.print("[green]✓ All files already cached[/green]")
+                    
+                    # Remove abs_path from manifest before sending to API
+                    file_manifest = [{"path": f["path"], "sha": f["sha"], "size": f["size"]} for f in file_manifest]
+
                 # Create deployment with real-time streaming
                 try:
                     status_result, deployment_id, logs_data = _stream_deployment(
@@ -478,9 +534,14 @@ def deploy(project_name, git_repo, branch, framework, region, size, no_heal):
                         is_dockerized=is_dockerized,
                         port=port,
                         command=command,
+                        entrypoint=entrypoint,  # Pass entrypoint to deployment API
                         database=database,
+                        package_manager=package_manager,
+                        dependency_file=dependency_file,
+                        file_manifest=file_manifest,
                     )
 
+
                     if status_result == "FAILED" and not no_heal:
                         # Hand off to the Zen Nod AI Agent
                         should_retry = zen_nod_workflow(logs_data, client, attempt)

{xenfra-0.4.2 → xenfra-0.4.3}/src/xenfra/utils/config.py

@@ -67,6 +67,10 @@ def generate_xenfra_yaml(analysis: CodebaseAnalysisResponse, filename: str = "xe
         "port": analysis.port,
     }
 
+    # Add entrypoint if detected (e.g., "todo.main:app")
+    if hasattr(analysis, 'entrypoint') and analysis.entrypoint:
+        config["entrypoint"] = analysis.entrypoint
+
     # Add database configuration if detected
     if analysis.database and analysis.database != "none":
         config["database"] = {"type": analysis.database, "env_var": "DATABASE_URL"}

xenfra-0.4.3/src/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)