xenfra 0.3.8__tar.gz

xenfra-0.3.8/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.3
+Name: xenfra
+Version: 0.3.8
+Summary: A 'Zen Mode' infrastructure engine for Python developers.
+Author: xenfra-cloud
+Author-email: xenfra-cloud <xenfracloud@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Requires-Dist: click>=8.1.7
+Requires-Dist: rich>=14.2.0
+Requires-Dist: sqlmodel>=0.0.16
+Requires-Dist: python-digitalocean>=1.17.0
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: fabric>=3.2.2
+Requires-Dist: xenfra-sdk
+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: toml>=0.10.2
+Requires-Dist: pytest>=8.0.0 ; extra == 'test'
+Requires-Dist: pytest-mock>=3.12.0 ; extra == 'test'
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/xenfra-cloud/xenfra
+Project-URL: Issues, https://github.com/xenfra-cloud/xenfra/issues
+Provides-Extra: test
+Description-Content-Type: text/markdown
+
+# Xenfra CLI
+
+## Xenfra CLI: Deploy Python Apps with Zen Mode
+
+The Xenfra CLI is a powerful and intuitive command-line interface designed to streamline the deployment of Python applications to DigitalOcean. Built with a "Zen Mode" philosophy, it automates complex infrastructure tasks, allowing developers to focus on writing code.
+
+### ✨ Key Features
+
+- **Zero-Configuration Deployment:** Automatically detects your project's framework and dependencies.
+- **AI-Powered Auto-Healing:** Diagnoses common deployment failures and suggests, or even applies, fixes automatically.
+- **Real-time Monitoring:** View deployment status and stream live application logs directly from your terminal.
+- **Integrated Project Management:** Easily list, view, and destroy your deployed projects.
+- **Secure Authentication:** Uses OAuth2 PKCE flow for secure, token-based authentication.
+
+### 🚀 Quickstart
+
+#### 1. Installation
+
+Install the Xenfra CLI using `uv` (recommended) or `pip`:
+
+```bash
+uv pip install xenfra-cli
+# or
+pip install xenfra-cli
+```
+
+#### 2. Authentication
+
+Log in to your Xenfra account. This will open your web browser to complete the OAuth2 flow.
+
+```bash
+xenfra auth login
+```
+
+#### 3. Initialize Your Project
+
+Navigate to your Python project's root directory and run `init`. The CLI will scan your codebase, detect its characteristics, and generate a `xenfra.yaml` configuration file.
+
+```bash
+cd your-python-project/
+xenfra init
+```
+
+#### 4. Deploy Your Application
+
+Once `xenfra.yaml` is configured, deploy your application. The CLI will handle provisioning a DigitalOcean Droplet, setting up Docker, and deploying your code.
+
+```bash
+xenfra deploy
+```
+
+### 📋 Usage Examples
+
+- **Monitor Deployment Status:**
+  ```bash
+  xenfra status <deployment-id>
+  ```
+- **Stream Application Logs:**
+  ```bash
+  xenfra logs <deployment-id>
+  ```
+- **List Deployed Projects:**
+  ```bash
+  xenfra projects list
+  ```
+- **Diagnose a Failed Deployment (AI-Powered):**
+  ```bash
+  xenfra diagnose <deployment-id>
+  # Or to diagnose from a log file:
+  xenfra diagnose --logs error.log
+  ```
+
+### 📚 Documentation
+
+For more detailed information, advanced configurations, and API references, please refer to the [official Xenfra Documentation](https://docs.xenfra.tech/cli) (Link will be updated upon final deployment).
+
+### 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guidelines](CONTRIBUTING.md) for more details.
+
+### 📄 License
+
+This project is licensed under the [MIT License](LICENSE).

xenfra-0.3.8/README.md

@@ -0,0 +1,83 @@
+# Xenfra CLI
+
+## Xenfra CLI: Deploy Python Apps with Zen Mode
+
+The Xenfra CLI is a powerful and intuitive command-line interface designed to streamline the deployment of Python applications to DigitalOcean. Built with a "Zen Mode" philosophy, it automates complex infrastructure tasks, allowing developers to focus on writing code.
+
+### ✨ Key Features
+
+- **Zero-Configuration Deployment:** Automatically detects your project's framework and dependencies.
+- **AI-Powered Auto-Healing:** Diagnoses common deployment failures and suggests, or even applies, fixes automatically.
+- **Real-time Monitoring:** View deployment status and stream live application logs directly from your terminal.
+- **Integrated Project Management:** Easily list, view, and destroy your deployed projects.
+- **Secure Authentication:** Uses OAuth2 PKCE flow for secure, token-based authentication.
+
+### 🚀 Quickstart
+
+#### 1. Installation
+
+Install the Xenfra CLI using `uv` (recommended) or `pip`:
+
+```bash
+uv pip install xenfra-cli
+# or
+pip install xenfra-cli
+```
+
+#### 2. Authentication
+
+Log in to your Xenfra account. This will open your web browser to complete the OAuth2 flow.
+
+```bash
+xenfra auth login
+```
+
+#### 3. Initialize Your Project
+
+Navigate to your Python project's root directory and run `init`. The CLI will scan your codebase, detect its characteristics, and generate a `xenfra.yaml` configuration file.
+
+```bash
+cd your-python-project/
+xenfra init
+```
+
+#### 4. Deploy Your Application
+
+Once `xenfra.yaml` is configured, deploy your application. The CLI will handle provisioning a DigitalOcean Droplet, setting up Docker, and deploying your code.
+
+```bash
+xenfra deploy
+```
+
+### 📋 Usage Examples
+
+- **Monitor Deployment Status:**
+  ```bash
+  xenfra status <deployment-id>
+  ```
+- **Stream Application Logs:**
+  ```bash
+  xenfra logs <deployment-id>
+  ```
+- **List Deployed Projects:**
+  ```bash
+  xenfra projects list
+  ```
+- **Diagnose a Failed Deployment (AI-Powered):**
+  ```bash
+  xenfra diagnose <deployment-id>
+  # Or to diagnose from a log file:
+  xenfra diagnose --logs error.log
+  ```
+
+### 📚 Documentation
+
+For more detailed information, advanced configurations, and API references, please refer to the [official Xenfra Documentation](https://docs.xenfra.tech/cli) (Link will be updated upon final deployment).
+
+### 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guidelines](CONTRIBUTING.md) for more details.
+
+### 📄 License
+
+This project is licensed under the [MIT License](LICENSE).

xenfra-0.3.8/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "xenfra"
+version = "0.3.8"
+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.3.8/src/xenfra/commands/__init__.py

@@ -0,0 +1,3 @@
+"""
+CLI command modules for Xenfra.
+"""

xenfra-0.3.8/src/xenfra/commands/auth.py

@@ -0,0 +1,144 @@
+"""
+Authentication commands for Xenfra CLI.
+"""
+
+import base64
+import hashlib
+import secrets
+import urllib.parse
+import webbrowser
+from http.server import HTTPServer
+
+import click
+import httpx
+import keyring
+from rich.console import Console
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from ..utils.auth import (
+    API_BASE_URL,
+    CLI_CLIENT_ID,
+    CLI_LOCAL_SERVER_END_PORT,
+    CLI_LOCAL_SERVER_START_PORT,
+    CLI_REDIRECT_PATH,
+    SERVICE_ID,
+    AuthCallbackHandler,
+    clear_tokens,
+    get_auth_token,
+)
+
+console = Console()
+
+# HTTP request timeout (30 seconds)
+HTTP_TIMEOUT = 30.0
+
+
+@click.group()
+def auth():
+    """Authentication commands (login, logout, whoami)."""
+    pass
+
+
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=2, max=10),
+    retry=retry_if_exception_type((httpx.TimeoutException, httpx.NetworkError)),
+    reraise=True,
+)
+def _exchange_code_for_tokens_with_retry(code: str, code_verifier: str, redirect_uri: str) -> dict:
+    """
+    Exchange authorization code for tokens with retry logic.
+
+    Returns token data dictionary.
+    """
+    with httpx.Client(timeout=HTTP_TIMEOUT) as client:
+        response = client.post(
+            f"{API_BASE_URL}/auth/token",
+            data={
+                "grant_type": "authorization_code",
+                "client_id": CLI_CLIENT_ID,
+                "code": code,
+                "code_verifier": code_verifier,
+                "redirect_uri": redirect_uri,
+            },
+            headers={"Accept": "application/json"},
+        )
+        response.raise_for_status()
+
+        # Safe JSON parsing with content-type check
+        content_type = response.headers.get("content-type", "")
+        if "application/json" not in content_type:
+            raise ValueError(f"Expected JSON response, got {content_type}")
+
+        try:
+            token_data = response.json()
+        except (ValueError, TypeError) as e:
+            raise ValueError(f"Failed to parse JSON response: {e}")
+
+        return token_data
+
+
+@auth.command()
+def login():
+    """Login to Xenfra using Device Authorization Flow (like GitHub CLI, Claude Code)."""
+    from .auth_device import device_login
+    device_login()
+
+    # Removed old PKCE flow - now using Device Authorization Flow
+
+
+@auth.command()
+def logout():
+    """Logout and clear stored tokens."""
+    try:
+        clear_tokens()
+        console.print("[bold green]Logged out successfully.[/bold green]")
+    except Exception as e:
+        console.print(f"[yellow]Warning: Error during logout: {e}[/yellow]")
+        console.print("[dim]Tokens may still be stored in keyring.[/dim]")
+
+
+@auth.command()
+@click.option("--token", is_flag=True, help="Show access token")
+def whoami(token):
+    """Show current authenticated user."""
+    access_token = get_auth_token()
+
+    if not access_token:
+        console.print("[bold red]Not logged in. Run 'xenfra login' first.[/bold red]")
+        return
+
+    try:
+        import base64
+        import json
+
+        # Manually decode JWT payload without verification
+        # JWT format: header.payload.signature
+        parts = access_token.split(".")
+        if len(parts) != 3:
+            console.print("[bold red]Invalid token format[/bold red]")
+            return
+
+        # Decode payload (second part)
+        payload_b64 = parts[1]
+        # Add padding if needed
+        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("[bold green]Logged in as:[/bold green]")
+        console.print(f"  Email: {claims.get('sub', 'N/A')}")
+        console.print(f"  User ID: {claims.get('user_id', 'N/A')}")
+
+        if token:
+            console.print(f"\n[dim]Access Token:[/dim]\n{access_token}")
+    except Exception as e:
+        console.print(f"[bold red]Failed to decode token: {e}[/bold red]")

xenfra-0.3.8/src/xenfra/commands/auth_device.py

@@ -0,0 +1,164 @@
+"""
+Device Authorization Flow for Xenfra CLI.
+Modern OAuth flow used by GitHub CLI, AWS CLI, Claude Code, etc.
+"""
+
+import time
+import webbrowser
+from urllib.parse import urlencode
+
+import click
+import httpx
+import keyring
+from rich.console import Console
+from rich.panel import Panel
+
+from ..utils.auth import API_BASE_URL, CLI_CLIENT_ID, HTTP_TIMEOUT, SERVICE_ID
+
+console = Console()
+
+
+def device_login():
+    """
+    Device Authorization Flow (OAuth 2.0 Device Grant).
+
+    Flow:
+    1. CLI calls /auth/device/authorize to get device_code and user_code
+    2. User visits https://www.xenfra.tech/activate and enters user_code
+    3. CLI polls /auth/device/token until user authorizes
+    4. CLI receives access_token and stores it
+    """
+    try:
+        # Step 1: Request device code
+        console.print("[cyan]Initiating device authorization...[/cyan]")
+
+        with httpx.Client(timeout=HTTP_TIMEOUT) as client:
+            response = client.post(
+                f"{API_BASE_URL}/auth/device/authorize",
+                data={
+                    "client_id": CLI_CLIENT_ID,
+                    "scope": "openid profile",
+                },
+            )
+            response.raise_for_status()
+            device_data = response.json()
+
+        device_code = device_data["device_code"]
+        user_code = device_data["user_code"]
+        verification_uri = device_data["verification_uri"]
+        verification_uri_complete = device_data.get("verification_uri_complete")
+        expires_in = device_data["expires_in"]
+        interval = device_data.get("interval", 5)
+
+        # Step 2: Show user code and open browser
+        console.print()
+        console.print(
+            Panel.fit(
+                f"[bold white]{user_code}[/bold white]",
+                title="[bold green]Your Activation Code[/bold green]",
+                border_style="green",
+            )
+        )
+        console.print()
+        console.print(f"[bold]Visit:[/bold] [link]{verification_uri}[/link]")
+        console.print(f"[bold]Enter code:[/bold] [cyan]{user_code}[/cyan]")
+        console.print()
+
+        # Open browser automatically
+        try:
+            url_to_open = verification_uri_complete or verification_uri
+            webbrowser.open(url_to_open)
+            console.print("[dim]Opening browser...[/dim]")
+        except Exception:
+            console.print("[yellow]Could not open browser automatically. Please visit the URL above.[/yellow]")
+
+        # Step 3: Poll for authorization
+        console.print()
+        console.print("[cyan]Waiting for authorization...[/cyan]")
+        console.print("[dim](Press Ctrl+C to cancel)[/dim]")
+        console.print()
+
+        start_time = time.time()
+        poll_count = 0
+
+        with httpx.Client(timeout=HTTP_TIMEOUT) as client:
+            while True:
+                # Check timeout
+                if time.time() - start_time > expires_in:
+                    console.print("[bold red]✗ Authorization timed out. Please try again.[/bold red]")
+                    return False
+
+                # Poll the token endpoint
+                try:
+                    response = client.post(
+                        f"{API_BASE_URL}/auth/device/token",
+                        data={
+                            "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                            "device_code": device_code,
+                            "client_id": CLI_CLIENT_ID,
+                        },
+                    )
+
+                    if response.status_code == 200:
+                        # Success! User authorized
+                        token_data = response.json()
+                        access_token = token_data["access_token"]
+                        refresh_token = token_data.get("refresh_token")
+
+                        # Store tokens (keyring or file fallback)
+                        try:
+                            keyring.set_password(SERVICE_ID, "access_token", access_token)
+                            if refresh_token:
+                                keyring.set_password(SERVICE_ID, "refresh_token", refresh_token)
+                        except keyring.errors.KeyringError as e:
+                            console.print(f"[dim]Keyring unavailable, using file storage: {e}[/dim]")
+                            # Fallback to file storage
+                            from ..utils.auth import _set_token_to_file
+                            _set_token_to_file("access_token", access_token)
+                            if refresh_token:
+                                _set_token_to_file("refresh_token", refresh_token)
+
+                        console.print()
+                        console.print("[bold green]✓ Successfully authenticated![/bold green]")
+                        console.print()
+                        return True
+
+                    elif response.status_code == 400:
+                        error_data = response.json()
+                        error = error_data.get("error", "unknown_error")
+
+                        if error == "authorization_pending":
+                            # Still waiting for user to authorize
+                            poll_count += 1
+                            if poll_count % 6 == 0:  # Every 30 seconds
+                                console.print("[dim]Still waiting...[/dim]")
+                            time.sleep(interval)
+                            continue
+
+                        elif error == "slow_down":
+                            # We're polling too fast
+                            interval += 5
+                            time.sleep(interval)
+                            continue
+
+                        else:
+                            # Other error
+                            error_desc = error_data.get("error_description", error)
+                            console.print(f"[bold red]✗ Authorization failed: {error_desc}[/bold red]")
+                            return False
+
+                    else:
+                        console.print(f"[bold red]✗ Unexpected response: {response.status_code}[/bold red]")
+                        return False
+
+                except httpx.HTTPError as e:
+                    console.print(f"[bold red]✗ Network error: {e}[/bold red]")
+                    return False
+
+    except KeyboardInterrupt:
+        console.print()
+        console.print("[yellow]Authorization cancelled.[/yellow]")
+        return False
+    except Exception as e:
+        console.print(f"[bold red]✗ Error: {e}[/bold red]")
+        return False