superqode 0.1.9__tar.gz → 0.1.10__tar.gz

{superqode-0.1.9/src/superqode.egg-info → superqode-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 0.1.9
+Version: 0.1.10
 Summary: SuperQode: Super Quality Engineering for Agentic Coding Teams
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-0.1.9 → superqode-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "0.1.9"
+version = "0.1.10"
 description = "SuperQode: Super Quality Engineering for Agentic Coding Teams"
 readme = "README.md"
 requires-python = ">=3.12"

{superqode-0.1.9 → superqode-0.1.10}/src/superqode/__init__.py

@@ -30,4 +30,4 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "0.1.8"
+__version__ = "0.1.10"

superqode-0.1.10/src/superqode/auth/__init__.py

@@ -0,0 +1,264 @@
+"""
+Local Auth Storage for SuperQode.
+
+Simple, minimal local storage for API keys. Inspired by opencode's approach.
+
+Security:
+- File permissions set to 0o600 (owner read/write only)
+- Stored in ~/.superqode/auth.json
+- Never logs or exposes key values
+
+This is OPTIONAL - SuperQode still supports BYOK (env vars) as primary.
+Local storage is for users who prefer file-based key management.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+class AuthType(Enum):
+    """Type of authentication credential."""
+
+    API = "api"  # Simple API key
+    OAUTH = "oauth"  # OAuth with refresh token
+    WELLKNOWN = "wellknown"  # Well-known auth (key + token pair)
+
+
+@dataclass
+class ApiAuth:
+    """Simple API key authentication."""
+
+    type: str = "api"
+    key: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": self.type, "key": self.key}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ApiAuth":
+        return cls(type=data.get("type", "api"), key=data.get("key", ""))
+
+
+@dataclass
+class OAuthAuth:
+    """OAuth authentication with refresh token."""
+
+    type: str = "oauth"
+    refresh: str = ""
+    access: str = ""
+    expires: int = 0
+    account_id: Optional[str] = None
+    enterprise_url: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "type": self.type,
+            "refresh": self.refresh,
+            "access": self.access,
+            "expires": self.expires,
+        }
+        if self.account_id:
+            result["account_id"] = self.account_id
+        if self.enterprise_url:
+            result["enterprise_url"] = self.enterprise_url
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "OAuthAuth":
+        return cls(
+            type=data.get("type", "oauth"),
+            refresh=data.get("refresh", ""),
+            access=data.get("access", ""),
+            expires=data.get("expires", 0),
+            account_id=data.get("account_id"),
+            enterprise_url=data.get("enterprise_url"),
+        )
+
+    def is_expired(self) -> bool:
+        """Check if access token is expired."""
+        return self.expires > 0 and self.expires < int(datetime.now().timestamp())
+
+
+@dataclass
+class WellKnownAuth:
+    """Well-known authentication (key + token pair)."""
+
+    type: str = "wellknown"
+    key: str = ""
+    token: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": self.type, "key": self.key, "token": self.token}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "WellKnownAuth":
+        return cls(
+            type=data.get("type", "wellknown"),
+            key=data.get("key", ""),
+            token=data.get("token", ""),
+        )
+
+
+AuthInfo = Union[ApiAuth, OAuthAuth, WellKnownAuth]
+
+
+def parse_auth_info(data: Dict[str, Any]) -> Optional[AuthInfo]:
+    """Parse auth info from dict based on type."""
+    auth_type = data.get("type")
+    if auth_type == "api":
+        return ApiAuth.from_dict(data)
+    if auth_type == "oauth":
+        return OAuthAuth.from_dict(data)
+    if auth_type == "wellknown":
+        return WellKnownAuth.from_dict(data)
+    return None
+
+
+class LocalAuthStorage:
+    """
+    Local storage for API keys and OAuth tokens.
+
+    Stores credentials in ~/.superqode/auth.json with restricted permissions.
+
+    Usage:
+        auth = LocalAuthStorage()
+
+        # Set API key
+        auth.set("anthropic", ApiAuth(key="sk-..."))
+
+        # Get credentials
+        creds = auth.get("anthropic")
+
+        # Remove
+        auth.remove("anthropic")
+
+        # List all
+        all_creds = auth.all()
+    """
+
+    DEFAULT_PATH = Path.home() / ".superqode" / "auth.json"
+
+    def __init__(self, filepath: Optional[Path] = None):
+        self.filepath = filepath or self.DEFAULT_PATH
+        self._ensure_dir()
+
+    def _ensure_dir(self) -> None:
+        """Ensure parent directory exists with proper permissions."""
+        parent = self.filepath.parent
+        if not parent.exists():
+            parent.mkdir(parents=True, mode=0o700)
+
+    def _read_file(self) -> Dict[str, Any]:
+        """Read auth file, return empty dict if not exists or invalid."""
+        if not self.filepath.exists():
+            return {}
+        try:
+            with open(self.filepath) as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+    def _write_file(self, data: Dict[str, Any]) -> None:
+        """Write auth file with secure permissions."""
+        # Write to temp file first, then rename (atomic)
+        temp_path = self.filepath.with_suffix(".tmp")
+        with open(temp_path, "w") as f:
+            json.dump(data, f, indent=2)
+
+        # Set permissions before moving
+        os.chmod(temp_path, 0o600)
+
+        # Atomic rename
+        temp_path.rename(self.filepath)
+
+    def get(self, provider_id: str) -> Optional[AuthInfo]:
+        """Get credentials for a provider."""
+        data = self._read_file()
+        if provider_id not in data:
+            return None
+        return parse_auth_info(data[provider_id])
+
+    def all(self) -> Dict[str, AuthInfo]:
+        """Get all stored credentials."""
+        data = self._read_file()
+        result: Dict[str, AuthInfo] = {}
+        for key, value in data.items():
+            if isinstance(value, dict):
+                parsed = parse_auth_info(value)
+                if parsed:
+                    result[key] = parsed
+        return result
+
+    def set(self, provider_id: str, info: AuthInfo) -> None:
+        """Set credentials for a provider."""
+        data = self._read_file()
+        data[provider_id] = info.to_dict()
+        self._write_file(data)
+        logger.debug(f"Saved auth for {provider_id}")
+
+    def remove(self, provider_id: str) -> bool:
+        """Remove credentials for a provider. Returns True if removed."""
+        data = self._read_file()
+        if provider_id not in data:
+            return False
+        del data[provider_id]
+        self._write_file(data)
+        logger.debug(f"Removed auth for {provider_id}")
+        return True
+
+    def exists(self, provider_id: str) -> bool:
+        """Check if credentials exist for a provider."""
+        return provider_id in self._read_file()
+
+    def clear(self) -> None:
+        """Clear all stored credentials."""
+        self._write_file({})
+        logger.debug("Cleared all auth")
+
+
+# Singleton instance
+_storage: Optional[LocalAuthStorage] = None
+
+
+def get_storage() -> LocalAuthStorage:
+    """Get the singleton auth storage instance."""
+    global _storage
+    if _storage is None:
+        _storage = LocalAuthStorage()
+    return _storage
+
+
+# Convenience functions
+def get(provider_id: str) -> Optional[AuthInfo]:
+    """Get credentials for a provider."""
+    return get_storage().get(provider_id)
+
+
+def all() -> Dict[str, AuthInfo]:
+    """Get all stored credentials."""
+    return get_storage().all()
+
+
+def set(provider_id: str, info: AuthInfo) -> None:
+    """Set credentials for a provider."""
+    get_storage().set(provider_id, info)
+
+
+def remove(provider_id: str) -> bool:
+    """Remove credentials for a provider."""
+    return get_storage().remove(provider_id)
+
+
+def exists(provider_id: str) -> bool:
+    """Check if credentials exist for a provider."""
+    return get_storage().exists(provider_id)

{superqode-0.1.9 → superqode-0.1.10}/src/superqode/commands/acp.py

@@ -780,136 +780,136 @@ def install_agent(agent_identifier: str) -> int:
                 )
                 return 1
 
-    # Pre-flight checks
-    _console.print(f"[bold cyan]🚀 Installing {agent['name']}[/bold cyan]")
-    _console.print(f"[dim]{agent.get('description', '')}[/dim]")
-    _console.print()
+        # Pre-flight checks
+        _console.print(f"[bold cyan]🚀 Installing {agent['name']}[/bold cyan]")
+        _console.print(f"[dim]{agent.get('description', '')}[/dim]")
+        _console.print()
 
-    # Check system dependencies
-    deps = check_system_dependencies()
-    missing_deps = [dep for dep, available in deps.items() if not available]
+        # Check system dependencies
+        deps = check_system_dependencies()
+        missing_deps = [dep for dep, available in deps.items() if not available]
+
+        if missing_deps:
+            _console.print("[yellow]⚠️ Missing system dependencies detected:[/yellow]")
+            for dep in missing_deps:
+                _console.print(f"  [red]• {dep}[/red]")
+
+            # Try to auto-install critical dependencies
+            critical_deps = ["uv"]  # Add more as needed
+            for dep in critical_deps:
+                if dep in missing_deps:
+                    if not install_system_dependency(dep):
+                        _console.print(
+                            f"[red]Cannot proceed without {dep}. Please install it manually.[/red]"
+                        )
+                        return 1
+
+            _console.print()
+
+        # Get the install command for current OS
+        install_command = get_os_command(actions, "install")
+        if not install_command:
+            _console.print("[red]No installation command found for this agent on your OS.[/red]")
+            return 1
 
-    if missing_deps:
-        _console.print("[yellow]⚠️ Missing system dependencies detected:[/yellow]")
-        for dep in missing_deps:
-            _console.print(f"  [red]• {dep}[/red]")
+        # Check for bootstrap_uv flag
+        needs_uv_bootstrap = False
+        for os_actions in actions.values():
+            if isinstance(os_actions, dict) and os_actions.get("bootstrap_uv", False):
+                needs_uv_bootstrap = True
+                break
 
-        # Try to auto-install critical dependencies
-        critical_deps = ["uv"]  # Add more as needed
-        for dep in critical_deps:
-            if dep in missing_deps:
-                if not install_system_dependency(dep):
-                    _console.print(
-                        f"[red]Cannot proceed without {dep}. Please install it manually.[/red]"
-                    )
-                    return 1
+        # Bootstrap UV if needed
+        if needs_uv_bootstrap and not deps.get("uv", False):
+            _console.print("[cyan]Bootstrapping UV package manager...[/cyan]")
+            if not install_system_dependency("uv"):
+                _console.print("[red]UV bootstrap failed. Cannot proceed.[/red]")
+                return 1
 
+        _console.print(f"[green]Installing {agent['name']}...[/green]")
+        _console.print(f"[dim]Command: {install_command}[/dim]")
         _console.print()
 
-    # Get the install command for current OS
-    install_command = get_os_command(actions, "install")
-    if not install_command:
-        _console.print("[red]No installation command found for this agent on your OS.[/red]")
-        return 1
-
-    # Check for bootstrap_uv flag
-    needs_uv_bootstrap = False
-    for os_actions in actions.values():
-        if isinstance(os_actions, dict) and os_actions.get("bootstrap_uv", False):
-            needs_uv_bootstrap = True
-            break
-
-    # Bootstrap UV if needed
-    if needs_uv_bootstrap and not deps.get("uv", False):
-        _console.print("[cyan]Bootstrapping UV package manager...[/cyan]")
-        if not install_system_dependency("uv"):
-            _console.print("[red]UV bootstrap failed. Cannot proceed.[/red]")
-            return 1
-
-    _console.print(f"[green]Installing {agent['name']}...[/green]")
-    _console.print(f"[dim]Command: {install_command}[/dim]")
-    _console.print()
+        # Run the installation command with progress feedback
+        try:
+            # Use a more interactive approach for long-running installs
+            process = subprocess.Popen(
+                install_command,
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+                universal_newlines=True,
+            )
 
-    # Run the installation command with progress feedback
-    try:
-        # Use a more interactive approach for long-running installs
-        process = subprocess.Popen(
-            install_command,
-            shell=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            bufsize=1,
-            universal_newlines=True,
-        )
+            # Show progress
+            _console.print("[cyan]Installation in progress...[/cyan]")
 
-        # Show progress
-        _console.print("[cyan]Installation in progress...[/cyan]")
+            # Wait for completion
+            stdout, stderr = process.communicate()
 
-        # Wait for completion
-        stdout, stderr = process.communicate()
+            if process.returncode == 0:
+                _console.print("[green]✓ Installation completed successfully![/green]")
 
-        if process.returncode == 0:
-            _console.print("[green]✓ Installation completed successfully![/green]")
+                # Verify installation
+                if check_agent_installed(agent):
+                    _console.print(f"[green]✓ Agent '{agent['short_name']}' is ready to use![/green]")
+                    _console.print(f"[dim]Try: superqode agents connect {agent['short_name']}[/dim]")
+                else:
+                    _console.print("[yellow]⚠️ Agent installed but verification failed[/yellow]")
+                    _console.print(
+                        "[dim]You may need to restart your shell or check the installation manually[/dim]"
+                    )
 
-            # Verify installation
-            if check_agent_installed(agent):
-                _console.print(f"[green]✓ Agent '{agent['short_name']}' is ready to use![/green]")
-                _console.print(f"[dim]Try: superqode agents connect {agent['short_name']}[/dim]")
+                return 0
             else:
-                _console.print("[yellow]⚠️ Agent installed but verification failed[/yellow]")
-                _console.print(
-                    f"[dim]You may need to restart your shell or check the installation manually[/dim]"
-                )
+                _console.print(f"[red]✗ Installation failed (exit code {process.returncode})[/red]")
 
-            return 0
-        else:
-            _console.print(f"[red]✗ Installation failed (exit code {process.returncode})[/red]")
+                # Enhanced error analysis
+                error_msg = stderr.lower() if stderr else ""
 
-            # Enhanced error analysis
-            error_msg = stderr.lower() if stderr else ""
+                if "eacces" in error_msg or "permission denied" in error_msg:
+                    _console.print("[yellow]💡 Permission Error:[/yellow]")
+                    _console.print("  This command requires administrator privileges.")
+                    _console.print(f"  Try: [bold]sudo {install_command}[/bold]")
+                    _console.print(
+                        "  Or use a Node version manager like nvm/fnm for user-space installation"
+                    )
+                elif "command not found" in error_msg or "npm: command not found" in error_msg:
+                    _console.print("[yellow]💡 Missing npm:[/yellow]")
+                    _console.print("  Node.js/npm is not installed. Install from:")
+                    _console.print("  https://nodejs.org/ or use your system package manager")
+                elif "uv: command not found" in error_msg:
+                    _console.print("[yellow]💡 Missing UV:[/yellow]")
+                    _console.print("  UV package manager is not installed. Install with:")
+                    _console.print("  curl -LsSf https://astral.sh/uv/install.sh | sh")
+                elif "certificate" in error_msg or "ssl" in error_msg:
+                    _console.print("[yellow]💡 SSL/Certificate Error:[/yellow]")
+                    _console.print("  There may be network or certificate issues.")
+                    _console.print("  Try updating your system's CA certificates.")
+                else:
+                    # Show the actual error output
+                    if stdout.strip():
+                        _console.print("[dim]Output:[/dim]")
+                        _console.print(stdout.strip())
+                    if stderr.strip():
+                        _console.print("[dim]Error:[/dim]")
+                        _console.print(stderr.strip())
 
-            if "eacces" in error_msg or "permission denied" in error_msg:
-                _console.print("[yellow]💡 Permission Error:[/yellow]")
-                _console.print("  This command requires administrator privileges.")
-                _console.print(f"  Try: [bold]sudo {install_command}[/bold]")
                 _console.print(
-                    "  Or use a Node version manager like nvm/fnm for user-space installation"
+                    f"\n[dim]💡 Alternative: Try installing manually with: {install_command}[/dim]"
                 )
-            elif "command not found" in error_msg or "npm: command not found" in error_msg:
-                _console.print("[yellow]💡 Missing npm:[/yellow]")
-                _console.print("  Node.js/npm is not installed. Install from:")
-                _console.print("  https://nodejs.org/ or use your system package manager")
-            elif "uv: command not found" in error_msg:
-                _console.print("[yellow]💡 Missing UV:[/yellow]")
-                _console.print("  UV package manager is not installed. Install with:")
-                _console.print("  curl -LsSf https://astral.sh/uv/install.sh | sh")
-            elif "certificate" in error_msg or "ssl" in error_msg:
-                _console.print("[yellow]💡 SSL/Certificate Error:[/yellow]")
-                _console.print("  There may be network or certificate issues.")
-                _console.print("  Try updating your system's CA certificates.")
-            else:
-                # Show the actual error output
-                if stdout.strip():
-                    _console.print("[dim]Output:[/dim]")
-                    _console.print(stdout.strip())
-                if stderr.strip():
-                    _console.print("[dim]Error:[/dim]")
-                    _console.print(stderr.strip())
+                return 1
 
+        except FileNotFoundError:
             _console.print(
-                f"\n[dim]💡 Alternative: Try installing manually with: {install_command}[/dim]"
+                "[red]Command not found. Please ensure required dependencies are installed.[/red]"
             )
             return 1
-
-    except FileNotFoundError:
-        _console.print(
-            f"[red]Command not found. Please ensure required dependencies are installed.[/red]"
-        )
-        return 1
-    except Exception as e:
-        _console.print(f"[red]Installation error: {e}[/red]")
-        return 1
+        except Exception as e:
+            _console.print(f"[red]Installation error: {e}[/red]")
+            return 1
 
     try:
         return asyncio.run(install_agent_async())