agentic-fabriq-sdk 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

af_cli/core/output.py

@@ -0,0 +1,180 @@
+"""
+Output formatting utilities for the Agentic Fabric CLI.
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from af_cli.core.config import get_config
+
+console = Console()
+
+
+def success(message: str) -> None:
+    """Print success message."""
+    console.print(f"✅ {message}", style="green")
+
+
+def error(message: str) -> None:
+    """Print error message."""
+    console.print(f"❌ {message}", style="red")
+
+
+def warning(message: str) -> None:
+    """Print warning message."""
+    console.print(f"⚠️ {message}", style="yellow")
+
+
+def info(message: str) -> None:
+    """Print info message."""
+    console.print(f"ℹ️ {message}", style="blue")
+
+
+def debug(message: str) -> None:
+    """Print debug message if verbose mode is enabled."""
+    config = get_config()
+    if config.verbose:
+        console.print(f"🔍 {message}", style="dim")
+
+
+def print_table(
+    data: List[Dict[str, Any]],
+    columns: Optional[List[str]] = None,
+    title: Optional[str] = None,
+) -> None:
+    """Print data as a table."""
+    if not data:
+        warning("No data to display")
+        return
+    
+    # Use provided columns or infer from first row
+    if columns is None:
+        columns = list(data[0].keys())
+    
+    # Create table
+    table = Table(title=title)
+    
+    # Add columns
+    for column in columns:
+        table.add_column(column.replace("_", " ").title(), style="cyan")
+    
+    # Add rows
+    for row in data:
+        table.add_row(*[str(row.get(col, "")) for col in columns])
+    
+    console.print(table)
+
+
+def print_json(data: Any) -> None:
+    """Print data as JSON."""
+    console.print_json(json.dumps(data, indent=2, default=str))
+
+
+def print_yaml(data: Any) -> None:
+    """Print data as YAML."""
+    console.print(yaml.dump(data, default_flow_style=False))
+
+
+def print_output(
+    data: Any,
+    format_type: Optional[str] = None,
+    columns: Optional[List[str]] = None,
+    title: Optional[str] = None,
+) -> None:
+    """Print output in the specified format."""
+    config = get_config()
+    format_type = format_type or config.output_format
+    
+    if format_type == "json":
+        print_json(data)
+    elif format_type == "yaml":
+        print_yaml(data)
+    elif format_type == "table":
+        if isinstance(data, list):
+            print_table(data, columns, title)
+        else:
+            # Convert single item to table format
+            if isinstance(data, dict):
+                table_data = [{"Field": k, "Value": v} for k, v in data.items()]
+                print_table(table_data, ["Field", "Value"], title)
+            else:
+                console.print(str(data))
+    else:
+        console.print(str(data))
+
+
+def print_status(
+    resource_type: str,
+    resource_id: str,
+    status: str,
+    details: Optional[Dict[str, Any]] = None,
+) -> None:
+    """Print resource status."""
+    status_color = {
+        "created": "green",
+        "updated": "blue",
+        "deleted": "red",
+        "error": "red",
+        "warning": "yellow",
+    }.get(status, "white")
+    
+    message = f"{resource_type} {resource_id} {status}"
+    console.print(message, style=status_color)
+    
+    if details and get_config().verbose:
+        for key, value in details.items():
+            console.print(f"  {key}: {value}", style="dim")
+
+
+def prompt_confirm(message: str, default: bool = False) -> bool:
+    """Prompt for confirmation."""
+    default_text = "Y/n" if default else "y/N"
+    response = console.input(f"{message} [{default_text}]: ")
+    
+    if not response:
+        return default
+    
+    return response.lower() in ["y", "yes"]
+
+
+def prompt_input(message: str, default: Optional[str] = None) -> str:
+    """Prompt for input."""
+    if default:
+        message = f"{message} [{default}]"
+    
+    response = console.input(f"{message}: ")
+    
+    if not response and default:
+        return default
+    
+    return response
+
+
+def format_timestamp(timestamp: str) -> str:
+    """Format timestamp for display."""
+    try:
+        from datetime import datetime
+        dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except:
+        return timestamp
+
+
+def format_size(size: int) -> str:
+    """Format file size for display."""
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size < 1024.0:
+            return f"{size:.1f}{unit}"
+        size /= 1024.0
+    return f"{size:.1f}PB"
+
+
+def truncate_text(text: str, max_length: int = 50) -> str:
+    """Truncate text for display."""
+    if len(text) <= max_length:
+        return text
+    return text[:max_length - 3] + "..." 

af_cli/core/token_storage.py

@@ -0,0 +1,263 @@
+"""
+Secure token storage for Agentic Fabric CLI.
+
+This module provides secure storage for authentication tokens using the system keychain
+(macOS Keychain, Windows Credential Manager, Linux Secret Service) with fallback to
+encrypted file storage.
+"""
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Dict, Optional
+
+try:
+    import keyring
+    KEYRING_AVAILABLE = True
+except ImportError:
+    KEYRING_AVAILABLE = False
+    keyring = None
+
+import jwt
+from cryptography.fernet import Fernet
+from pydantic import BaseModel
+
+
+class TokenData(BaseModel):
+    """Token data model."""
+    
+    access_token: str
+    refresh_token: Optional[str] = None
+    expires_at: int  # Unix timestamp
+    tenant_id: Optional[str] = None
+    user_id: Optional[str] = None
+    email: Optional[str] = None
+    name: Optional[str] = None
+
+
+class TokenStorage:
+    """Secure token storage using system keychain or encrypted files."""
+    
+    SERVICE_NAME = "agentic-fabriq-cli"
+    ACCOUNT_NAME = "default"
+    
+    def __init__(self, use_keyring: bool = True):
+        """
+        Initialize token storage.
+        
+        Args:
+            use_keyring: Whether to use system keyring (falls back to file if unavailable)
+        """
+        self.use_keyring = use_keyring and KEYRING_AVAILABLE
+        self.config_dir = Path.home() / ".af"
+        self.token_file = self.config_dir / "tokens.enc"
+        self.key_file = self.config_dir / ".key"
+        
+        # Ensure config directory exists
+        self.config_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+    
+    def _get_encryption_key(self) -> bytes:
+        """
+        Get or create encryption key for file storage.
+        
+        Returns:
+            Fernet encryption key
+        """
+        if self.key_file.exists():
+            with open(self.key_file, 'rb') as f:
+                return f.read()
+        else:
+            # Generate new key
+            key = Fernet.generate_key()
+            with open(self.key_file, 'wb') as f:
+                f.write(key)
+            # Set restrictive permissions
+            os.chmod(self.key_file, 0o600)
+            return key
+    
+    def save(self, token_data: TokenData) -> None:
+        """
+        Save token data securely.
+        
+        Args:
+            token_data: Token data to save
+        """
+        # Serialize token data
+        token_json = token_data.json()
+        
+        if self.use_keyring:
+            # Use system keyring
+            try:
+                keyring.set_password(
+                    self.SERVICE_NAME,
+                    self.ACCOUNT_NAME,
+                    token_json
+                )
+                return
+            except Exception as e:
+                # Fall back to file storage
+                print(f"Warning: Keyring storage failed, using file storage: {e}")
+                self.use_keyring = False
+        
+        # Fall back to encrypted file storage
+        key = self._get_encryption_key()
+        fernet = Fernet(key)
+        
+        encrypted_data = fernet.encrypt(token_json.encode('utf-8'))
+        
+        with open(self.token_file, 'wb') as f:
+            f.write(encrypted_data)
+        
+        # Set restrictive permissions
+        os.chmod(self.token_file, 0o600)
+    
+    def load(self) -> Optional[TokenData]:
+        """
+        Load token data.
+        
+        Returns:
+            Token data if available, None otherwise
+        """
+        token_json = None
+        
+        if self.use_keyring:
+            # Try system keyring first
+            try:
+                token_json = keyring.get_password(
+                    self.SERVICE_NAME,
+                    self.ACCOUNT_NAME
+                )
+            except Exception:
+                # Fall back to file storage
+                self.use_keyring = False
+        
+        if not token_json and self.token_file.exists():
+            # Try encrypted file storage
+            try:
+                key = self._get_encryption_key()
+                fernet = Fernet(key)
+                
+                with open(self.token_file, 'rb') as f:
+                    encrypted_data = f.read()
+                
+                token_json = fernet.decrypt(encrypted_data).decode('utf-8')
+            except Exception as e:
+                print(f"Warning: Failed to load tokens from file: {e}")
+                return None
+        
+        if token_json:
+            try:
+                return TokenData.parse_raw(token_json)
+            except Exception as e:
+                print(f"Warning: Failed to parse token data: {e}")
+                return None
+        
+        return None
+    
+    def delete(self) -> None:
+        """Delete stored token data."""
+        if self.use_keyring:
+            # Delete from keyring
+            try:
+                keyring.delete_password(
+                    self.SERVICE_NAME,
+                    self.ACCOUNT_NAME
+                )
+            except Exception:
+                pass
+        
+        # Delete file storage
+        if self.token_file.exists():
+            try:
+                self.token_file.unlink()
+            except Exception:
+                pass
+    
+    def is_token_expired(self, token_data: Optional[TokenData] = None) -> bool:
+        """
+        Check if token is expired.
+        
+        Args:
+            token_data: Token data to check (loads from storage if not provided)
+            
+        Returns:
+            True if token is expired or invalid
+        """
+        if token_data is None:
+            token_data = self.load()
+        
+        if not token_data:
+            return True
+        
+        # Add 60 second buffer to account for clock skew
+        return time.time() >= (token_data.expires_at - 60)
+    
+    def parse_jwt_claims(self, access_token: str) -> Dict:
+        """
+        Parse JWT token claims without validation.
+        
+        Args:
+            access_token: JWT access token
+            
+        Returns:
+            Dictionary of claims
+        """
+        try:
+            # Decode without verification (we trust the token from Keycloak)
+            claims = jwt.decode(
+                access_token,
+                options={"verify_signature": False}
+            )
+            return claims
+        except Exception:
+            return {}
+    
+    def extract_token_info(self, tokens: Dict) -> TokenData:
+        """
+        Extract and parse token information.
+        
+        Args:
+            tokens: Token response from OAuth endpoint
+            
+        Returns:
+            Structured token data
+        """
+        access_token = tokens['access_token']
+        refresh_token = tokens.get('refresh_token')
+        expires_in = tokens.get('expires_in', 3600)
+        
+        # Calculate expiration time
+        expires_at = int(time.time()) + expires_in
+        
+        # Parse JWT claims
+        claims = self.parse_jwt_claims(access_token)
+        
+        # Extract user info from claims
+        tenant_id = claims.get('tenant_id') or claims.get('tenant')
+        user_id = claims.get('sub')
+        email = claims.get('email')
+        name = claims.get('name') or claims.get('preferred_username')
+        
+        return TokenData(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            email=email,
+            name=name
+        )
+
+
+# Global token storage instance
+_token_storage: Optional[TokenStorage] = None
+
+
+def get_token_storage() -> TokenStorage:
+    """Get the global token storage instance."""
+    global _token_storage
+    if _token_storage is None:
+        _token_storage = TokenStorage()
+    return _token_storage
+

af_cli/main.py

@@ -0,0 +1,187 @@
+"""
+Main CLI application for Agentic Fabric.
+"""
+
+import os
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from af_cli.commands.agents import app as agents_app
+from af_cli.commands.auth import app as auth_app
+from af_cli.commands.config import app as config_app
+from af_cli.commands.mcp_servers import app as mcp_servers_app
+from af_cli.commands.secrets import app as secrets_app
+from af_cli.commands.tools import app as tools_app
+from af_cli.core.config import get_config
+from af_cli.core.output import success, error, info
+
+app = typer.Typer(
+    name="af",
+    help="Agentic Fabric CLI - Manage your connectivity hub",
+    add_completion=False,
+)
+
+console = Console()
+
+# Add subcommands
+app.add_typer(auth_app, name="auth", help="Authentication commands")
+app.add_typer(config_app, name="config", help="Configuration commands")
+app.add_typer(agents_app, name="agents", help="Agent management commands")
+app.add_typer(tools_app, name="tools", help="Tool management commands")
+app.add_typer(mcp_servers_app, name="mcp-servers", help="MCP server management commands")
+app.add_typer(secrets_app, name="secrets", help="Secret management commands")
+
+
+@app.command()
+def version():
+    """Show version information."""
+    from af_cli import __version__
+    console.print(f"Agentic Fabric CLI v{__version__}")
+
+
+@app.command()
+def status():
+    """Show system status and configuration."""
+    config = get_config()
+    
+    # Create status table
+    table = Table(title="Agentic Fabric Status")
+    table.add_column("Component", style="cyan")
+    table.add_column("Status", style="green")
+    table.add_column("Details", style="yellow")
+    
+    # Check gateway connection
+    try:
+        import httpx
+        response = httpx.get(f"{config.gateway_url}/health", timeout=5.0)
+        if response.status_code == 200:
+            table.add_row("Gateway", "✅ Online", config.gateway_url)
+        else:
+            table.add_row("Gateway", "❌ Error", f"Status: {response.status_code}")
+    except Exception as e:
+        table.add_row("Gateway", "❌ Offline", str(e))
+    
+    # Check authentication
+    if config.access_token:
+        table.add_row("Authentication", "✅ Authenticated", f"Tenant: {config.tenant_id}")
+    else:
+        table.add_row("Authentication", "❌ Not authenticated", "Run 'af auth login'")
+    
+    # Check configuration
+    config_path = config.config_file
+    if os.path.exists(config_path):
+        table.add_row("Configuration", "✅ Found", config_path)
+    else:
+        table.add_row("Configuration", "❌ Not found", config_path)
+    
+    console.print(table)
+
+
+@app.command()
+def init(
+    gateway_url: str = typer.Option(
+        "http://localhost:8000",
+        "--gateway-url",
+        "-g",
+        help="Gateway URL"
+    ),
+    tenant_id: Optional[str] = typer.Option(
+        None,
+        "--tenant-id",
+        "-t",
+        help="Tenant ID"
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force initialization, overwrite existing config"
+    ),
+):
+    """Initialize CLI configuration."""
+    config = get_config()
+    
+    # Check if config exists
+    if os.path.exists(config.config_file) and not force:
+        error(f"Configuration already exists at {config.config_file}")
+        error("Use --force to overwrite")
+        raise typer.Exit(1)
+    
+    # Create config directory if it doesn't exist
+    os.makedirs(os.path.dirname(config.config_file), exist_ok=True)
+    
+    # Save configuration
+    config.gateway_url = gateway_url
+    if tenant_id:
+        config.tenant_id = tenant_id
+    
+    config.save()
+    
+    success(f"Configuration initialized at {config.config_file}")
+    info(f"Gateway URL: {gateway_url}")
+    if tenant_id:
+        info(f"Tenant ID: {tenant_id}")
+    else:
+        info("Run 'af auth login' to authenticate")
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    config_file: Optional[str] = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Path to configuration file"
+    ),
+    gateway_url: Optional[str] = typer.Option(
+        None,
+        "--gateway-url",
+        "-g",
+        help="Gateway URL"
+    ),
+    tenant_id: Optional[str] = typer.Option(
+        None,
+        "--tenant-id",
+        "-t",
+        help="Tenant ID"
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Enable verbose output"
+    ),
+):
+    """
+    Agentic Fabric CLI - Manage your connectivity hub.
+    
+    The CLI provides commands for managing agents, tools, MCP servers, and secrets
+    in your Agentic Fabric deployment.
+    """
+    # Configure global options
+    config = get_config()
+    
+    if config_file:
+        config.config_file = config_file
+    
+    # Load configuration
+    config.load()
+    
+    # Override with command line options
+    if gateway_url:
+        config.gateway_url = gateway_url
+    if tenant_id:
+        config.tenant_id = tenant_id
+    
+    config.verbose = verbose
+    
+    # Store config in context
+    ctx.obj = config
+
+
+if __name__ == "__main__":
+    app()