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

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/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/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)

{xenfra-0.4.2.dist-info → xenfra-0.4.3.dist-info}/METADATA

@@ -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.dist-info → xenfra-0.4.3.dist-info}/RECORD

@@ -2,7 +2,7 @@ xenfra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xenfra/commands/__init__.py,sha256=kTTwVnTvoxikyPUhQiyTAbnw4PYafktuE1----TqQoA,43
 xenfra/commands/auth.py,sha256=ecReVCGl7Ys2d77mv_e4mCbs4ug6FLIb3S9dl2FUhr4,4178
 xenfra/commands/auth_device.py,sha256=caD2UdveEZtAFjgjmnA-l5bjbbPONFjXJXgeJN7mhbk,6710
-xenfra/commands/deployments.py,sha256=tnsEu98hC6KSt5dNM9ogscCDHSgzPI4F0K5fTvoi4iI,40060
+xenfra/commands/deployments.py,sha256=y4yF4_Itr6L0aUrHCwreHnJbVkWERAE874bKZPB_wY4,43722
 xenfra/commands/intelligence.py,sha256=95R12QnRq_uz42iUQ_4xKqIvN3nw2SAKd1H4AdLS6OI,17598
 xenfra/commands/projects.py,sha256=SAxF_pOr95K6uz35U-zENptKndKxJNZn6bcD45PHcpI,6696
 xenfra/commands/security_cmd.py,sha256=EI5sjX2lcMxgMH-LCFmPVkc9YqadOrcoSgTiKknkVRY,7327
@@ -10,11 +10,12 @@ xenfra/main.py,sha256=2EPPuIdxjhW-I-e-Mc0i2ayeLaSJdmzddNThkXq7B7c,2033
 xenfra/utils/__init__.py,sha256=4ZRYkrb--vzoXjBHG8zRxz2jCXNGtAoKNtkyu2WRI2A,45
 xenfra/utils/auth.py,sha256=9JbFnv0-rdlJF-4hKD2uWd9h9ehqC1iIHee1O5e-3RM,13769
 xenfra/utils/codebase.py,sha256=GMrqhOJWX8q5ZXSLI9P3hJZBpufXMQA3Z4fKh2XSTNo,5949
-xenfra/utils/config.py,sha256=Wcr1l7-0I46qGBPrgoG8SlvBKUEplksM8AaP6sTyT5I,15187
+xenfra/utils/config.py,sha256=tFfTnentYZmp7XXNS_hA0pe2WRHgiOl-fUZn2HcwhHI,15364
 xenfra/utils/errors.py,sha256=6G91YzzDDNkKHANTgfAMiOiMElEyi57wo6-FzRa4VuQ,4211
+xenfra/utils/file_sync.py,sha256=TFur1RMaATSjoZ9HNheha2UWxfFoib22iEyWB1vlCB8,7933
 xenfra/utils/security.py,sha256=EA8CIPLt8Y-QP5uZ7c5NuC6ZLRV1aZS8NapS9ix_vok,11479
 xenfra/utils/validation.py,sha256=cvuL_AEFJ2oCoP0abCqoOIABOwz79Gkf-jh_dcFIQlM,6912
-xenfra-0.4.2.dist-info/WHEEL,sha256=eycQt0QpYmJMLKpE3X9iDk8R04v2ZF0x82ogq-zP6bQ,79
-xenfra-0.4.2.dist-info/entry_points.txt,sha256=a_2cGhYK__X6eW05Ba8uB6RIM_61c2sHtXsPY8N0mic,45
-xenfra-0.4.2.dist-info/METADATA,sha256=KyQ8sRc__QMkmIg9_AYiArqXUgVEeD7hJx8L1ea2rsQ,3898
-xenfra-0.4.2.dist-info/RECORD,,
+xenfra-0.4.3.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+xenfra-0.4.3.dist-info/entry_points.txt,sha256=a_2cGhYK__X6eW05Ba8uB6RIM_61c2sHtXsPY8N0mic,45
+xenfra-0.4.3.dist-info/METADATA,sha256=zINMSKmaq5wdCgCNSF0w1oBcuuDYBIz5AjVjkuv84ds,3898
+xenfra-0.4.3.dist-info/RECORD,,

{xenfra-0.4.2.dist-info → xenfra-0.4.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.24
+Generator: uv 0.9.26
 Root-Is-Purelib: true
-Tag: py3-none-any
+Tag: py3-none-any