akashcli 3.0.0__py3-none-any.whl

akashcli/__init__.py

@@ -0,0 +1,6 @@
+# akashcli/__init__.py
+from .client import AkashClient
+from .models import UploadResult, FileInfo, UserInfo
+from .exceptions import AkashError
+
+__version__ = "2.0.0"

akashcli/auth.py

@@ -0,0 +1,51 @@
+import httpx
+import json
+from typing import Optional
+from .models import UserInfo
+from .exceptions import AuthenticationError, NetworkError
+from .config import ConfigManager
+from .crypto import SecureVault
+
+class AuthManager:
+    @staticmethod
+    def verify_remote_key(api_key: str, api_url: str) -> UserInfo:
+        """Calls the /api/verify endpoint to check key status."""
+        try:
+            with httpx.Client(base_url=api_url, timeout=10.0) as client:
+                response = client.get(
+                    "/api/verify", 
+                    headers={"x-api-key": api_key, "Origin": "https://akash.cli"}
+                )
+                
+                if response.status_code == 403:
+                    raise AuthenticationError("API Key is invalid or locked.")
+                
+                response.raise_for_status()
+                data = response.json()
+                
+                return UserInfo(
+                    owner=data["owner"],
+                    quota_used=data["quota_used"],
+                    quota_limit=data["quota_limit"],
+                    allowed_domains=data.get("allowed_domains", "*")
+                )
+        except httpx.RequestError as e:
+            raise NetworkError(f"Could not connect to Akash Vault: {e}")
+
+    @staticmethod
+    def perform_login(api_key: str, api_url: str) -> UserInfo:
+        """Verifies the key and persists it to the encrypted config."""
+        user_info = AuthManager.verify_remote_key(api_key, api_url)
+        
+        # Prepare data for local encrypted storage
+        config_data = {
+            "api_key": api_key,
+            "api_url": api_url,
+            "owner": user_info.owner
+        }
+        
+        # Encrypt and save
+        encrypted_blob = SecureVault.encrypt(json.dumps(config_data))
+        ConfigManager.save(encrypted_blob)
+        
+        return user_info

akashcli/cli.py

@@ -0,0 +1,184 @@
+import typer
+import json
+import os
+import subprocess
+import webbrowser
+import httpx
+from typing import Optional
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, DownloadColumn, TransferSpeedColumn
+from rich.panel import Panel
+
+# Internal Imports
+from .client import AkashClient
+from .auth import AuthManager
+from .config import ConfigManager
+from .exceptions import AkashError
+from .uploader import VaultUploader
+
+# 🌟 Removed the 'gh' overrides and panels
+app = typer.Typer(help="🛡️ Akash Vault Enterprise CLI", add_completion=True)
+console = Console()
+
+@app.command()
+def login(
+    url: str = typer.Option("https://jstore.2bd.net", "--url", help="Custom Vault URL"),
+    key: str = typer.Option(..., prompt="🔑 Enter API Key", hide_input=True)
+):
+    """🔑 Link your device to the vault."""
+    try:
+        with console.status("[bold blue]Verifying identity..."):
+            user = AuthManager.perform_login(key, url)
+        
+        console.print(f"[green]✓ Login Successful![/green] Owner: {user.owner}")
+    except Exception as e:
+        console.print(f"[bold red]✗ Authentication Failed:[/bold red] {e}")
+
+@app.command()
+def whoami():
+    """👤 Check current login and quota status."""
+    try:
+        client = AkashClient()
+        user = client.whoami()
+        console.print(f"Logged in as: [bold cyan]{user.owner}[/bold cyan]")
+        console.print(f"Storage Quota: [bold yellow]{user.quota_used}/{user.quota_limit}[/bold yellow]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+
+@app.command()
+def upload(
+    path: Optional[Path] = typer.Argument(None, help="Path to file"),
+    text: Optional[str] = typer.Option(None, "--text", "-t", help="Upload raw text content"),
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Custom filename"),
+    burn: bool = typer.Option(False, "--burn", help="Self-destruct after one view"),
+    expiry: int = typer.Option(0, "--expiry", "-e", help="Expiry in days (0 for forever)"),
+    password: Optional[str] = typer.Option(None, "--pass", "-p", help="Password protect file")
+):
+    """📤 Vault a single file or text snippet."""
+    try:
+        client = AkashClient()
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            console=console,
+            transient=True
+        ) as progress:
+            task = progress.add_task(description="[cyan]Processing...", total=100)
+            def update_bar(current, total):
+                progress.update(task, completed=(current/total)*100)
+
+            if text:
+                res = client.upload_text(text, filename=name, burn=burn, expiry=expiry, password=password)
+            else:
+                if not path:
+                    console.print("[red]Error:[/red] Provide a file path or use --text")
+                    return
+                res = client.upload_file(str(path), burn=burn, expiry=expiry, password=password, progress_callback=update_bar)
+
+        console.print(f"[bold green]✓ Vaulted![/bold green] Code: [yellow]{res.file_code}[/yellow]")
+    except Exception as e:
+        console.print(f"[bold red]✗ Upload Failed:[/bold red] {e}")
+
+@app.command()
+def files(json_output: bool = typer.Option(False, "--json", help="Output in raw JSON")):
+    """📦 List and search files in your vault."""
+    try:
+        client = AkashClient()
+        file_list = client.list_files()
+        
+        if json_output:
+            console.print_json(data=[f.__dict__ for f in file_list])
+            return
+
+        table = Table(title="📦 Encrypted Vault")
+        table.add_column("Filename", style="cyan")
+        table.add_column("Code", style="yellow")
+        table.add_column("Size", justify="right")
+
+        for f in file_list:
+            size_mb = f"{f.size / (1024*1024):.2f} MB"
+            table.add_row(f.name, f.code, size_mb)
+
+        console.print(table)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+
+@app.command()
+def stream(code: str, vlc: bool = typer.Option(False, "--vlc", help="Open directly in VLC")):
+    """🎬 Get a secure streaming link."""
+    client = AkashClient()
+    try:
+        with httpx.Client(base_url=client.base_url) as c:
+            resp = c.get(f"/api/stream/generate/{code}", headers=client._get_headers())
+            resp.raise_for_status()
+            url = resp.json()['stream_url']
+            
+        if vlc:
+            console.print(f"🎬 Launching VLC for: {code}")
+            subprocess.Popen(['vlc', url], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+        else:
+            console.print(f"🎬 Secure URL: {url}")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+
+@app.command()
+def delete(code: str):
+    """🗑️ Permanently remove a file."""
+    if typer.confirm(f"Are you sure you want to delete {code}?"):
+        try:
+            client = AkashClient()
+            client.delete_file(code)
+            console.print(f"[green]✓ Deleted {code}[/green]")
+        except Exception as e:
+            console.print(f"[red]Error:[/red] {e}")
+
+@app.command()
+def manage(
+    code: str, 
+    name: Optional[str] = typer.Option(None, "--name"),
+    burn: Optional[bool] = typer.Option(None, "--burn/--no-burn"),
+    expiry: Optional[int] = typer.Option(None, "--expiry")
+):
+    """⚙️ Modify settings for an existing file."""
+    try:
+        client = AkashClient()
+        updates = {}
+        if name: updates['filename'] = name
+        if burn is not None: updates['burn_on_read'] = 1 if burn else 0
+        if expiry is not None: updates['expiry_days'] = expiry
+        client.update_file(code, **updates)
+        console.print(f"[green]✓ Updated {code}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+
+@app.command()
+def bulk(path: Path):
+    """🚀 Recursive folder vaulting."""
+    try:
+        client = AkashClient()
+        uploader = VaultUploader(client)
+        files = [p for p in path.glob("**/*") if p.is_file() and not p.name.startswith('.')]
+        for file in files:
+            console.print(f"Vaulting: {file.name}")
+            uploader.upload(file_path=str(file))
+        console.print("[green]✓ Batch complete.[/green]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+
+@app.command()
+def docs():
+    """📖 View the integration guide."""
+    webbrowser.open("https://github.com/juniorsir/akashcli")
+
+@app.command()
+def logout():
+    """🚪 Clear local credentials."""
+    ConfigManager.save(b"") 
+    console.print("[yellow]Logged out.[/yellow]")
+
+if __name__ == "__main__":
+    app()

akashcli/client.py

@@ -0,0 +1,74 @@
+import httpx
+import time
+from typing import List, Optional
+from .models import UploadResult, FileInfo, UserInfo
+from .exceptions import *
+from .config import ConfigManager
+
+class AkashClient:
+    def __init__(self, api_key: Optional[str] = None, api_url: Optional[str] = None):
+        config = ConfigManager.load()
+        self.api_key = api_key or config.get("api_key")
+        self.base_url = (api_url or config.get("api_url", "https://jstore.2bd.net")).rstrip("/")
+        
+        if not self.api_key:
+            raise AuthenticationError("No API Key found. Run 'akash login'")
+
+    def _get_headers(self, custom: dict = None):
+        h = {"x-api-key": self.api_key, "Origin": "https://akash.cli"}
+        if custom: h.update(custom)
+        return h
+
+    def whoami(self) -> UserInfo:
+        with httpx.Client(base_url=self.base_url) as client:
+            resp = client.get("/api/me", headers=self._get_headers())
+            if resp.status_code != 200: raise AuthenticationError("Invalid Key")
+            d = resp.json()
+            return UserInfo(d['owner'], d['quota']['used'], d['quota']['limit'], d['allowed_domains'])
+
+    def upload_file(self, path: str, burn: bool = False, expiry: int = 0) -> UploadResult:
+        files = {"file": open(path, "rb")}
+        headers = {
+            "x-vault-burn": "1" if burn else "0",
+            "x-vault-expiry": str(expiry)
+        }
+        with httpx.Client(base_url=self.base_url, timeout=None) as client:
+            resp = client.post("/api/upload", headers=self._get_headers(headers), files=files)
+            resp.raise_for_status()
+            d = resp.json()
+            return UploadResult(
+                d['status'], d['file_code'], d['links']['embed'], 
+                d['links']['direct'], d['input_type'], d.get('dna', {})
+            )
+
+    def list_files(self) -> List[FileInfo]:
+        with httpx.Client(base_url=self.base_url) as client:
+            resp = client.get("/api/files", headers=self._get_headers())
+            return [FileInfo(f['name'], f['code'], f['size'], f['uploaded_at']) for f in resp.json()]
+
+    def delete_file(self, code: str):
+        with httpx.Client(base_url=self.base_url) as client:
+            client.delete(f"/api/files/{code}", headers=self._get_headers())
+
+    def upload_text(self, content: str, filename: str = None, burn: bool = False, expiry: int = 0, password: str = None):
+        from .uploader import VaultUploader
+        uploader = VaultUploader(self)
+        return uploader.upload(content=content, filename=filename, burn=burn, expiry=expiry, password=password)
+
+    def update_file(self, code: str, **kwargs) -> dict:
+        """Update file settings (filename, burn_on_read, expiry_days)."""
+        with httpx.Client(base_url=self.base_url) as client:
+            resp = client.patch(
+                f"/api/files/{code}", 
+                headers=self._get_headers(), 
+                json=kwargs
+            )
+            resp.raise_for_status()
+            return resp.json()
+
+    def get_stats(self) -> dict:
+        """Admin Only: Fetch global vault statistics."""
+        with httpx.Client(base_url=self.base_url) as client:
+            # Reuses the logic from your bot's show_stats
+            resp = client.get("/api/me", headers=self._get_headers())
+            return resp.json()

akashcli/config.py

@@ -0,0 +1,52 @@
+import os
+import pathlib
+import platform
+
+class ConfigManager:
+    APP_NAME = "Akash"
+    
+    @staticmethod
+    def get_config_dir() -> pathlib.Path:
+        """Determines the OS-specific directory for config storage."""
+        home = pathlib.Path.home()
+        system = platform.system()
+
+        if system == "Windows":
+            path = pathlib.Path(os.getenv("APPDATA", home / "AppData/Roaming")) / ConfigManager.APP_NAME
+        elif system == "Darwin":  # macOS
+            path = home / "Library/Application Support" / ConfigManager.APP_NAME
+        else:  # Linux / Termux
+            path = home / ".akash"
+            
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    @staticmethod
+    def get_config_path() -> pathlib.Path:
+        return ConfigManager.get_config_dir() / "config.enc"
+
+    @staticmethod
+    def save(encrypted_bytes: bytes):
+        """Writes the encrypted config to disk."""
+        path = ConfigManager.get_config_path()
+        with open(path, "wb") as f:
+            f.write(encrypted_bytes)
+
+    @staticmethod
+    def load() -> dict:
+        """Reads and decrypts the config file."""
+        from .crypto import SecureVault
+        import json
+        
+        path = ConfigManager.get_config_path()
+        if not path.exists():
+            return {}
+            
+        try:
+            with open(path, "rb") as f:
+                encrypted_data = f.read()
+            
+            decrypted_str = SecureVault.decrypt(encrypted_data)
+            return json.loads(decrypted_str)
+        except Exception:
+            return {}

akashcli/crypto.py

@@ -0,0 +1,42 @@
+import base64
+import os
+import json
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from .utils import get_device_id
+
+class SecureVault:
+    @staticmethod
+    def _get_fernet(salt: bytes) -> Fernet:
+        """Derives a deterministic key based on the hardware ID and a random salt."""
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=salt,
+            iterations=100000,
+        )
+        # Use hardware ID as the password for key derivation
+        key = base64.urlsafe_b64encode(kdf.derive(get_device_id().encode()))
+        return Fernet(key)
+
+    @staticmethod
+    def encrypt(data: str) -> bytes:
+        """Encrypts a string. Returns [16 bytes salt][ciphertext]."""
+        salt = os.urandom(16)
+        # 🌟 THE FIX: Call the helper via the Class name, not 'self'
+        f = SecureVault._get_fernet(salt)
+        return salt + f.encrypt(data.encode())
+
+    @staticmethod
+    def decrypt(token: bytes) -> str:
+        """Decrypts a token using the hardware-bound key."""
+        try:
+            if not token:
+                return "{}"
+            salt, ciphertext = token[:16], token[16:]
+            f = SecureVault._get_fernet(salt)
+            return f.decrypt(ciphertext).decode()
+        except Exception:
+            # If hardware ID changed or file is corrupt, return empty config
+            return "{}"

akashcli/exceptions.py

@@ -0,0 +1,27 @@
+class AkashError(Exception):
+    """Base exception for all Akash CLI/SDK errors."""
+    pass
+
+class AuthenticationError(AkashError):
+    """Raised when API Key is missing, invalid, or locked."""
+    pass
+
+class QuotaExceeded(AkashError):
+    """Raised when the user's upload quota (429) has been reached."""
+    pass
+
+class VaultFileNotFound(AkashError):
+    """Raised when a specific file code cannot be found in the vault."""
+    pass
+
+class UploadFailed(AkashError):
+    """Raised when a file or text upload fails due to network or server issues."""
+    pass
+
+class NetworkError(AkashError):
+    """Raised for general connection issues (timeout, DNS, etc.)."""
+    pass
+
+class ConfigError(AkashError):
+    """Raised when the local configuration is corrupt or unreadable."""
+    pass

akashcli/models.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import Optional, Dict
+from datetime import datetime
+
+@dataclass
+class UserInfo:
+    owner: str
+    quota_used: int
+    quota_limit: int
+    allowed_domains: str
+
+@dataclass
+class UploadResult:
+    status: str
+    file_code: str
+    embed_url: str
+    direct_url: str
+    input_type: str
+    dna: Dict[str, str]
+
+@dataclass
+class FileInfo:
+    name: str
+    code: str
+    size: int
+    uploaded_at: Optional[datetime] = None

akashcli/uploader.py

@@ -0,0 +1,123 @@
+import os
+import httpx, asyncio
+from pathlib import Path
+from typing import Optional, Callable, Dict, Any, List
+from concurrent.futures import ThreadPoolExecutor
+from .models import UploadResult
+from .exceptions import UploadFailed, QuotaExceeded
+
+class VaultUploader:
+    def __init__(self, client):
+        self.client = client # Reference to AkashClient for headers/url
+
+    def upload(
+        self, 
+        file_path: Optional[str] = None, 
+        content: Optional[str] = None,
+        filename: Optional[str] = None,
+        burn: bool = False,
+        expiry: int = 0,
+        password: Optional[str] = None,
+        progress_callback: Optional[Callable[[int, int], None]] = None
+    ) -> UploadResult:
+        """
+        Standardizes both File and Text uploads into a single stream.
+        progress_callback signature: (bytes_read, total_bytes)
+        """
+        
+        # 1. Prepare Headers based on V3 Power-Control Specs
+        headers = {
+            "x-vault-burn": "1" if burn else "0",
+            "x-vault-expiry": str(expiry),
+        }
+        if password:
+            headers["x-vault-password"] = password
+
+        url = f"{self.client.base_url}/api/upload"
+        
+        try:
+            if content is not None:
+                # --- TEXT SNIPPET MODE (JSON) ---
+                payload = {
+                    "content": content,
+                    "filename": filename or "snippet.txt"
+                }
+                resp = httpx.post(
+                    url, 
+                    json=payload, 
+                    headers=self.client._get_headers(headers),
+                    timeout=None
+                )
+            else:
+                # --- FILE MODE (Multipart) ---
+                if not file_path or not os.path.exists(file_path):
+                    raise UploadFailed(f"File not found: {file_path}")
+                
+                file_size = os.path.getsize(file_path)
+                
+                # Setup custom stream to track progress
+                def file_generator():
+                    with open(file_path, "rb") as f:
+                        chunk_size = 1024 * 1024 # 1MB chunks
+                        bytes_read = 0
+                        while chunk := f.read(chunk_size):
+                            bytes_read += len(chunk)
+                            if progress_callback:
+                                progress_callback(bytes_read, file_size)
+                            yield chunk
+
+                files = {"file": (os.path.basename(file_path), file_generator())}
+                
+                resp = httpx.post(
+                    url, 
+                    files=files, 
+                    headers=self.client._get_headers(headers),
+                    timeout=None
+                )
+
+            if resp.status_code == 429:
+                raise QuotaExceeded("Monthly upload quota reached.")
+            
+            resp.raise_for_status()
+            d = resp.json()
+            
+            return UploadResult(
+                status=d['status'],
+                file_code=d['file_code'],
+                embed_url=d['links']['embed'],
+                direct_url=d['links']['direct'],
+                input_type=d['input_type'],
+                dna=d.get('dna', {})
+            )
+
+        except httpx.HTTPStatusError as e:
+            raise UploadFailed(f"Server rejected upload ({e.response.status_code}): {e.response.text}")
+        except Exception as e:
+            raise UploadFailed(f"Unexpected error during upload: {e}")
+
+    def upload_directory(self, folder_path: str, max_workers: int = 3) -> List[UploadResult]:
+        """Recursively uploads all files in a folder using a thread pool."""
+        # Convert string path to Path object
+        root = Path(folder_path)
+        if not root.is_dir():
+            raise UploadFailed(f"Source is not a directory: {folder_path}")
+
+        # Find all files recursively (excluding hidden files/folders)
+        paths = [p for p in root.glob("**/*") if p.is_file() and not p.name.startswith('.')]
+        results = []
+        
+        # Using ThreadPoolExecutor for parallel I/O bound tasks
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # We wrap the self.upload calls into the executor
+            # Note: We don't pass a progress_callback here to avoid UI overlap 
+            # (The CLI 'bulk' command will handle the UI instead)
+            futures = [executor.submit(self.upload, file_path=str(p)) for p in paths]
+            
+            for f in futures:
+                try:
+                    results.append(f.result())
+                except Exception as e:
+                    # Log error but continue with other files
+                    print(f"Error uploading a file in batch: {e}")
+        
+        return results  

akashcli/utils.py

@@ -0,0 +1,9 @@
+import uuid
+import hashlib
+import platform
+
+def get_device_id() -> str:
+    """Generates a unique hardware fingerprint."""
+    # Combine node (MAC address) and system info for a stable ID
+    raw_id = f"{uuid.getnode()}-{platform.node()}-{platform.processor()}"
+    return hashlib.sha256(raw_id.encode()).hexdigest()

akashcli-3.0.0.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: akashcli
+Version: 3.0.0
+Summary: Enterprise Developer SDK and CLI for Akash Vault
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: httpx
+Requires-Dist: typer[all]
+Requires-Dist: rich
+Requires-Dist: cryptography
+
+To get started with **AkashCLI**, your users should follow these steps. You can provide this guide as a `README.md` or a "Getting Started" message in your bot.
+
+---
+
+# 🚀 Akash Vault: Getting Started Guide
+
+**AkashCLI** is the professional command-line interface and SDK for interacting with your E2E encrypted vault. Follow these steps to install and secure your first files.
+
+## 1. Prerequisites
+Ensure you have **Python 3.10+** and `pip` installed on your machine (Linux, Termux, Mac, or Windows).
+
+## 2. Installation
+Since this is a custom package, users can install it directly from your source code or repository:
+
+```bash
+# Clone the repository
+git clone https://github.com/juniorsir/akashcli
+cd akashcli
+
+# Install in editable mode
+pip install . --break-system-packages
+```
+
+---
+
+## 3. First-Time Setup (Authentication)
+Before using the vault, you must link your device using an API Key generated from the [Akash Telegram Bot](https://t.me/EveryDL_bot).
+
+1.  Open the Bot and go to **👤 My Account** -> **🔑 Generate API Key**.
+2.  In your terminal, run:
+    ```bash
+    akash login
+    ```
+3.  Enter your API Key when prompted. Your key will be **encrypted and bound to your hardware** automatically.
+
+---
+
+## 4. Daily Workflow Commands
+
+### 📤 Uploading Content
+**Upload a file:**
+```bash
+akash upload movie.mp4
+```
+
+**Upload a secret text snippet:**
+```bash
+akash upload --text "My secret server password is 1234" --name "passwords.txt"
+```
+
+**Upload with security flags:**
+```bash
+# Delete automatically after the first person views it
+akash upload --burn secret_doc.pdf
+
+# Set a 7-day expiry
+akash upload --expiry 7 data_backup.zip
+```
+
+### 📦 Managing the Vault
+**List your most recent files:**
+```bash
+akash files
+```
+
+**Get file details or secure links:**
+```bash
+akash stream FILE_CODE
+```
+
+**Delete a file permanently:**
+```bash
+akash delete FILE_CODE
+```
+
+---
+
+## 5. Professional Features
+
+### 🚀 Bulk Vaulting
+Vault an entire folder of documents or images at once:
+```bash
+akash bulk ./my_documents_folder
+```
+
+### 🎬 Native Streaming
+Stream a vaulted video directly into **VLC Media Player** without downloading:
+```bash
+akash stream FILE_CODE --vlc
+```
+
+### 📊 System Health
+Check your remaining quota and vault status:
+```bash
+akash admin
+```
+
+---
+
+## 6. Using the SDK (For Developers)
+If you are building your own Python scripts, you can import the library directly:
+
+```python
+from akashcli import AkashClient
+
+# Initialize client (uses your encrypted local config)
+client = AkashClient()
+
+# Vault a log file
+result = client.upload_file("system.log", expiry=30)
+print(f"File secured! Access it at: {result.embed_url}")
+
+# List all your files programmatically
+for file in client.list_files():
+    print(f"{file.name} -> {file.code}")
+```
+
+---
+
+## 💡 Troubleshooting
+*   **Access Denied?** Ensure you have set your API Key domains to `*` in the Telegram Bot under "Edit Domains."
+*   **VLC not opening?** Ensure the `vlc` command is available in your system's PATH.
+*   **Forgot your key?** Run `akash login` again to overwrite the old session.
+
+---
+**🛡️ Powered by Akash Enterprise Core.**

akashcli-3.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+akashcli/__init__.py,sha256=KfZTt-MEKFMfITPwtmrAVwR3SpFNxMD4aIp9HtUcKoQ,166
+akashcli/auth.py,sha256=Z4T15Khzm5OZSmpi2bX5fY9lNQDJBQLNOI8AZP3Z8GQ,1877
+akashcli/cli.py,sha256=9pVLjLUxdSMqg4eGfFy5i6X_M-9fJ-x-GqdTP4zHGvM,6813
+akashcli/client.py,sha256=CiIjsenjmJJPTgNjoD0cREQzaHDBoM5vbSxFtT4JqDQ,3319
+akashcli/config.py,sha256=tmygJ_Pub1X31y1atrhXL79w6M6ya7xgECfzP5tdEIE,1591
+akashcli/crypto.py,sha256=qZrd5m9zciX91MrE7FCPVFwqu-OPyGnx2sg5QxIAvlU,1486
+akashcli/exceptions.py,sha256=UgAKUghVHPt8MP9LwgzaypB1yLJYEu7PzThk55JasMo,786
+akashcli/models.py,sha256=jTWAlm0L15zE5iSrDvLCFeidfp1eSyq75ITJgLmwoB4,470
+akashcli/uploader.py,sha256=1sbofW67HZ2W5rR271foES6KqlTctm98z7-NWnK9oik,4818
+akashcli/utils.py,sha256=gcpMgr1MYKW-lVN1EvlhB3_OFM-exYnoBkpmVDdTPAs,317
+akashcli-3.0.0.dist-info/METADATA,sha256=PT3PMwFqhg6gzsWPB2oEwqcbFy-IMiRJiulUhiNAPz4,3407
+akashcli-3.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+akashcli-3.0.0.dist-info/entry_points.txt,sha256=aLc6XROFswqJxANSF-7GDq3F4PaOy42quTIxhDwMSrc,43
+akashcli-3.0.0.dist-info/top_level.txt,sha256=p49Zj2joNmEOddr96g8B6G7Rdiy1idOJtIv3gcv6T80,9
+akashcli-3.0.0.dist-info/RECORD,,

akashcli-3.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

akashcli-3.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+akash = akashcli.cli:app

akashcli-3.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+akashcli