xenfra 0.3.3__tar.gz → 0.3.5__tar.gz

{xenfra-0.3.3 → xenfra-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: xenfra
-Version: 0.3.3
+Version: 0.3.5
 Summary: A 'Zen Mode' infrastructure engine for Python developers.
 Author: xenfra-cloud
 Author-email: xenfra-cloud <xenfracloud@gmail.com>
@@ -23,6 +23,7 @@ Requires-Dist: httpx>=0.27.0
 Requires-Dist: keyring>=25.7.0
 Requires-Dist: keyrings-alt>=5.0.2
 Requires-Dist: tenacity>=8.2.3
+Requires-Dist: cryptography>=43.0.0
 Requires-Dist: pytest>=8.0.0 ; extra == 'test'
 Requires-Dist: pytest-mock>=3.12.0 ; extra == 'test'
 Requires-Python: >=3.13

{xenfra-0.3.3 → xenfra-0.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xenfra"
-version = "0.3.3"
+version = "0.3.5"
 description = "A 'Zen Mode' infrastructure engine for Python developers."
 readme = "README.md"
 authors = [
@@ -30,6 +30,7 @@ dependencies = [
     "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
 ]
 requires-python = ">=3.13"
 

{xenfra-0.3.3 → xenfra-0.3.5}/src/xenfra/commands/deployments.py

@@ -167,13 +167,11 @@ def deploy(project_name, git_repo, branch, framework, no_heal):
             console.print(f"[bold red]Invalid git repository URL: {error_msg}[/bold red]")
             raise click.Abort()
         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(
-            "[yellow]Local deployment requires code upload (not yet fully implemented).[/yellow]"
-        )
-        console.print("[dim]Please use --git-repo for now.[/dim]")
-        return
+        console.print("[dim]Code will be uploaded to the droplet[/dim]")
+        # Note: SDK's InfraEngine handles local upload via fabric.transfer.Upload()
 
     # Validate branch name
     is_valid, error_msg = validate_branch_name(branch)
@@ -215,12 +213,26 @@ def deploy(project_name, git_repo, branch, framework, no_heal):
 
                 # Create deployment
                 try:
-                    deployment = client.deployments.create(
-                        project_name=project_name,
-                        git_repo=git_repo,
-                        branch=branch,
-                        framework=framework,
-                    )
+                    from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
+                    
+                    with Progress(
+                        SpinnerColumn(),
+                        TextColumn("[bold blue]{task.description}"),
+                        BarColumn(),
+                        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                        console=console,
+                    ) as progress:
+                        # Track deployment phases
+                        task = progress.add_task("Creating deployment...", total=100)
+                        
+                        deployment = client.deployments.create(
+                            project_name=project_name,
+                            git_repo=git_repo,
+                            branch=branch,
+                            framework=framework,
+                        )
+                        
+                        progress.update(task, advance=100, description="Deployment created!")
 
                     deployment_id = deployment["deployment_id"]
                     console.print(
@@ -237,6 +249,8 @@ def deploy(project_name, git_repo, branch, framework, no_heal):
                     if git_repo:
                         details_table.add_row("Repository", git_repo)
                         details_table.add_row("Branch", branch)
+                    else:
+                        details_table.add_row("Source", "Local directory")
                     details_table.add_row("Framework", framework)
                     details_table.add_row("Status", deployment.get("status", "PENDING"))
 
@@ -260,8 +274,17 @@ def deploy(project_name, git_repo, branch, framework, no_heal):
                     break
 
                 except XenfraAPIError as e:
-                    # Deployment failed
-                    console.print(f"[bold red]✗ Deployment failed: {e.detail}[/bold red]")
+                    # Deployment failed - try to provide helpful error
+                    from ..utils.errors import detect_error_type, show_error_with_solution
+                    
+                    console.print(f"[bold red]✗ Deployment failed[/bold red]")
+                    
+                    # Try to detect error type and show solution
+                    error_type, error_kwargs = detect_error_type(str(e.detail))
+                    if error_type:
+                        show_error_with_solution(error_type, **error_kwargs)
+                    else:
+                        console.print(f"[red]{e.detail}[/red]")
 
                     # Check if we should auto-heal
                     if no_heal or attempt >= MAX_RETRY_ATTEMPTS:

{xenfra-0.3.3 → xenfra-0.3.5}/src/xenfra/commands/intelligence.py

@@ -34,40 +34,42 @@ def get_client() -> XenfraClient:
         console.print("[bold red]Not logged in. Run 'xenfra login' first.[/bold red]")
         raise click.Abort()
 
-    # DEBUG: Show token details
-    import base64
-    import json
-    try:
-        parts = token.split(".")
-        if len(parts) == 3:
-            # Decode payload
-            payload_b64 = parts[1]
-            padding = 4 - len(payload_b64) % 4
-            if padding != 4:
-                payload_b64 += "=" * padding
-            payload_bytes = base64.urlsafe_b64decode(payload_b64)
-            claims = json.loads(payload_bytes)
-
-            console.print("[dim]━━━ DEBUG: Token Info ━━━[/dim]")
-            console.print(f"[dim]  API URL: {API_BASE_URL}[/dim]")
-            console.print(f"[dim]  Token prefix: {token[:20]}...[/dim]")
-            console.print(f"[dim]  sub (email): {claims.get('sub', 'MISSING')}[/dim]")
-            console.print(f"[dim]  user_id: {claims.get('user_id', 'MISSING')}[/dim]")
-            console.print(f"[dim]  iss (issuer): {claims.get('iss', 'MISSING')}[/dim]")
-            console.print(f"[dim]  aud (audience): {claims.get('aud', 'MISSING')}[/dim]")
-
-            # Check if token is expired
-            exp = claims.get('exp')
-            if exp:
-                import time
-                is_expired = time.time() >= exp
-                from datetime import datetime, timezone
-                exp_time = datetime.fromtimestamp(exp, tz=timezone.utc)
-                console.print(f"[dim]  expires_at: {exp_time}[/dim]")
-                console.print(f"[dim]  expired: {is_expired}[/dim]")
-            console.print("[dim]━━━━━━━━━━━━━━━━━━━━━[/dim]\n")
-    except Exception as e:
-        console.print(f"[dim]DEBUG: Could not decode token: {e}[/dim]\n")
+    # DEBUG: Only show token info if XENFRA_DEBUG environment variable is set
+    import os
+    if os.getenv("XENFRA_DEBUG") == "1":
+        import base64
+        import json
+        try:
+            parts = token.split(".")
+            if len(parts) == 3:
+                # Decode payload
+                payload_b64 = parts[1]
+                padding = 4 - len(payload_b64) % 4
+                if padding != 4:
+                    payload_b64 += "=" * padding
+                payload_bytes = base64.urlsafe_b64decode(payload_b64)
+                claims = json.loads(payload_bytes)
+
+                console.print("[dim]━━━ DEBUG: Token Info ━━━[/dim]")
+                console.print(f"[dim]  API URL: {API_BASE_URL}[/dim]")
+                console.print(f"[dim]  Token prefix: {token[:20]}...[/dim]")
+                console.print(f"[dim]  sub (email): {claims.get('sub', 'MISSING')}[/dim]")
+                console.print(f"[dim]  user_id: {claims.get('user_id', 'MISSING')}[/dim]")
+                console.print(f"[dim]  iss (issuer): {claims.get('iss', 'MISSING')}[/dim]")
+                console.print(f"[dim]  aud (audience): {claims.get('aud', 'MISSING')}[/dim]")
+
+                # Check if token is expired
+                exp = claims.get('exp')
+                if exp:
+                    import time
+                    is_expired = time.time() >= exp
+                    from datetime import datetime, timezone
+                    exp_time = datetime.fromtimestamp(exp, tz=timezone.utc)
+                    console.print(f"[dim]  expires_at: {exp_time}[/dim]")
+                    console.print(f"[dim]  expired: {is_expired}[/dim]")
+                console.print("[dim]━━━━━━━━━━━━━━━━━━━━━[/dim]\n")
+        except Exception as e:
+            console.print(f"[dim]DEBUG: Could not decode token: {e}[/dim]\n")
 
     return XenfraClient(token=token, api_url=API_BASE_URL)
 
@@ -129,6 +131,20 @@ def init(manual, accept_all):
             # Call Intelligence Service
             analysis = client.intelligence.analyze_codebase(code_snippets)
 
+            # Client-side conflict detection (ensures Zen Nod always triggers)
+            from ..utils.codebase import detect_package_manager_conflicts
+            has_conflict_local, detected_managers_local = detect_package_manager_conflicts(code_snippets)
+
+            if has_conflict_local and not analysis.has_conflict:
+                # AI missed the conflict - fix it client-side
+                console.print("[dim]Note: Enhanced conflict detection activated[/dim]\n")
+                analysis.has_conflict = True
+                # Convert dict to object for compatibility
+                from types import SimpleNamespace
+                analysis.detected_package_managers = [
+                    SimpleNamespace(**pm) for pm in detected_managers_local
+                ]
+
         # Display results
         console.print("\n[bold green]Analysis Complete![/bold green]\n")
 

{xenfra-0.3.3 → xenfra-0.3.5}/src/xenfra/utils/auth.py

@@ -124,37 +124,89 @@ def _refresh_token_with_retry(refresh_token: str) -> dict:
         return token_data
 
 
+def _get_encryption_key() -> bytes:
+    """
+    Get or create encryption key for file-based token storage.
+
+    Uses machine-specific identifier to generate key (not perfect but better than plaintext).
+    """
+    import platform
+    import hashlib
+
+    # Use machine ID + username as seed (available on Windows/Linux/Mac)
+    machine_id = platform.node() + os.getlogin()
+    key = hashlib.sha256(machine_id.encode()).digest()[:32]  # 32 bytes for Fernet
+    return key
+
+
 def _get_token_from_file(key: str) -> str | None:
     """Fallback: Get token from file storage (for Windows if keyring fails)."""
     try:
         if TOKEN_FILE.exists():
+            with open(TOKEN_FILE, "rb") as f:
+                encrypted_data = f.read()
+
+            # Decrypt the file contents
+            from cryptography.fernet import Fernet
+            import base64
+
+            fernet_key = base64.urlsafe_b64encode(_get_encryption_key())
+            cipher = Fernet(fernet_key)
+            decrypted_data = cipher.decrypt(encrypted_data)
+            tokens = json.loads(decrypted_data.decode())
+            return tokens.get(key)
+    except Exception:
+        # If decryption fails, try reading as plaintext (for backward compatibility)
+        try:
             with open(TOKEN_FILE, "r") as f:
                 tokens = json.load(f)
                 return tokens.get(key)
-    except Exception:
-        pass
+        except Exception:
+            pass
     return None
 
 
 def _set_token_to_file(key: str, value: str):
-    """Fallback: Save token to file storage (for Windows if keyring fails)."""
+    """Fallback: Save token to file storage (encrypted for Windows if keyring fails)."""
     try:
         TOKEN_FILE.parent.mkdir(parents=True, exist_ok=True)
 
-        # Load existing tokens
+        # Load existing tokens (try encrypted first, then plaintext)
         tokens = {}
         if TOKEN_FILE.exists():
-            with open(TOKEN_FILE, "r") as f:
-                tokens = json.load(f)
+            try:
+                with open(TOKEN_FILE, "rb") as f:
+                    encrypted_data = f.read()
+                from cryptography.fernet import Fernet
+                import base64
+
+                fernet_key = base64.urlsafe_b64encode(_get_encryption_key())
+                cipher = Fernet(fernet_key)
+                decrypted_data = cipher.decrypt(encrypted_data)
+                tokens = json.loads(decrypted_data.decode())
+            except Exception:
+                # Fallback to plaintext for backward compatibility
+                try:
+                    with open(TOKEN_FILE, "r") as f:
+                        tokens = json.load(f)
+                except Exception:
+                    tokens = {}
 
         # Update token
         tokens[key] = value
 
-        # Save (with restrictive permissions on Unix-like systems)
-        with open(TOKEN_FILE, "w") as f:
-            json.dump(tokens, f)
+        # Encrypt and save
+        from cryptography.fernet import Fernet
+        import base64
+
+        fernet_key = base64.urlsafe_b64encode(_get_encryption_key())
+        cipher = Fernet(fernet_key)
+        encrypted_data = cipher.encrypt(json.dumps(tokens).encode())
+
+        with open(TOKEN_FILE, "wb") as f:
+            f.write(encrypted_data)
 
-        # Set file permissions (owner read/write only)
+        # Set file permissions (owner read/write only) - works on Unix-like systems
         if os.name != "nt":  # Not Windows
             TOKEN_FILE.chmod(0o600)
     except Exception as e:
@@ -195,9 +247,11 @@ def get_auth_token() -> str | None:
     try:
         access_token = keyring.get_password(SERVICE_ID, "access_token")
         refresh_token = keyring.get_password(SERVICE_ID, "refresh_token")
-        console.print("[dim]DEBUG: Token retrieved from keyring[/dim]")
+        if os.getenv("XENFRA_DEBUG") == "1":
+            console.print("[dim]DEBUG: Token retrieved from keyring[/dim]")
     except keyring.errors.KeyringError as e:
-        console.print(f"[dim]DEBUG: Keyring unavailable, using file storage: {e}[/dim]")
+        if os.getenv("XENFRA_DEBUG") == "1":
+            console.print(f"[dim]DEBUG: Keyring unavailable, using file storage: {e}[/dim]")
         use_file_fallback = True
         access_token = _get_token_from_file("access_token")
         refresh_token = _get_token_from_file("refresh_token")

{xenfra-0.3.3 → xenfra-0.3.5}/src/xenfra/utils/codebase.py

@@ -120,6 +120,49 @@ def scan_codebase(max_files: int = 10, max_size: int = 50000) -> dict[str, str]:
 
     return code_snippets
 
+def detect_package_manager_conflicts(code_snippets: dict[str, str]) -> tuple[bool, list[dict]]:
+    """
+    Deterministically detect package manager conflicts from scanned files.
+    
+    This ensures Zen Nod (conflict resolution) always triggers when multiple
+    package managers are present, regardless of AI detection.
+    
+    Args:
+        code_snippets: Dictionary of filename -> content from scan_codebase()
+    
+    Returns:
+        (has_conflict, detected_managers) where detected_managers is a list of
+        {"manager": str, "file": str} dictionaries
+    """
+    detected = []
+    
+    # Check for Python package managers
+    if "pyproject.toml" in code_snippets:
+        content = code_snippets["pyproject.toml"]
+        if "[tool.poetry]" in content or "poetry.lock" in code_snippets:
+            detected.append({"manager": "poetry", "file": "pyproject.toml"})
+        elif "[tool.uv]" in content or "uv.lock" in code_snippets or "[project]" in content:
+            detected.append({"manager": "uv", "file": "pyproject.toml"})
+    
+    if "Pipfile" in code_snippets:
+        detected.append({"manager": "pipenv", "file": "Pipfile"})
+    
+    if "requirements.txt" in code_snippets:
+        detected.append({"manager": "pip", "file": "requirements.txt"})
+    
+    # Check for Node.js package managers (all independent checks)
+    if "pnpm-lock.yaml" in code_snippets:
+        detected.append({"manager": "pnpm", "file": "pnpm-lock.yaml"})
+    
+    if "yarn.lock" in code_snippets:
+        detected.append({"manager": "yarn", "file": "yarn.lock"})
+    
+    if "package-lock.json" in code_snippets:
+        detected.append({"manager": "npm", "file": "package-lock.json"})
+    
+    has_conflict = len(detected) > 1
+    return has_conflict, detected
+
 
 def has_xenfra_config() -> bool:
     """Check if xenfra.yaml already exists."""

xenfra-0.3.5/src/xenfra/utils/errors.py

@@ -0,0 +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, {}