easyrunner-cli 0.0.8.dev97__tar.gz → 0.0.8.dev99__tar.gz

{easyrunner_cli-0.0.8.dev97 → easyrunner_cli-0.0.8.dev99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyrunner_cli
-Version: 0.0.8.dev97
+Version: 0.0.8.dev99
 Summary: EasyRunner CLI.
 Author: Janaka Abeywardhana
 Author-email: janaka@easyrunner.xyz

{easyrunner_cli-0.0.8.dev97 → easyrunner_cli-0.0.8.dev99}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "easyrunner_cli"
-version = "0.0.8.dev97"
+version = "0.0.8.dev99"
 description = "EasyRunner CLI."
 authors = ["Janaka Abeywardhana <janaka@easyrunner.xyz>"]
 license = ""

easyrunner_cli-0.0.8.dev99/source/auth/__init__.py

@@ -0,0 +1,10 @@
+from .github_device_flow import DeviceCodeResponse, GitHubDeviceFlow
+from .github_oauth_config import GitHubOAuthConfig
+from .github_token_manager import GitHubTokenManager
+
+__all__ = [
+    "DeviceCodeResponse",
+    "GitHubDeviceFlow",
+    "GitHubOAuthConfig",
+    "GitHubTokenManager",
+]

easyrunner_cli-0.0.8.dev99/source/auth/auth_sub_command.py

@@ -0,0 +1,238 @@
+import logging
+from typing import Optional, Self
+
+import typer
+from rich.console import Console
+from typer import Option
+
+from .github_device_flow import GitHubDeviceFlow
+from .github_oauth_config import GitHubOAuthConfig
+from .github_token_manager import GitHubTokenManager
+
+logger = logging.getLogger(__name__)
+
+
+class LinkSubCommand:
+    """Link external services to EasyRunner."""
+
+    typer_app: typer.Typer = typer.Typer(
+        name="link",
+        no_args_is_help=True,
+        rich_markup_mode="rich",
+        help="[bold green]Link[/bold green] external services to EasyRunner. Connect GitHub and other service providers.",
+    )
+
+    debug: bool = False
+    silent: bool = False
+
+    _console: Console = Console()
+    _print = _console.print
+
+    # Define progress callback with CLI-specific formatting
+    @staticmethod
+    def _progress_callback(message: str, end: str) -> None:
+        if not LinkSubCommand.silent:
+            LinkSubCommand._print(message, end=end)
+
+    def __init__(self: Self) -> None:
+        @self.typer_app.callback(invoke_without_command=True)
+        def set_global_options(  # type: ignore
+            debug: bool = Option(
+                False,
+                "--debug",
+                help="Enables extra debug messages to be output. Independent of --silent.",
+                rich_help_panel="Global Options",
+            ),
+            silent: bool = Option(
+                False,
+                "--silent",
+                help="Suppresses all output messages.",
+                rich_help_panel="Global Options",
+            ),
+        ) -> None:
+            LinkSubCommand.debug = debug
+            LinkSubCommand.silent = silent
+            if debug:
+                logger.setLevel(logging.DEBUG)
+            elif silent:
+                logger.setLevel(logging.ERROR)
+
+    @typer_app.command(
+        name="github",
+        help="Link GitHub to EasyRunner. This will allow EasyRunner to manage deploy keys for your repositories.",
+        no_args_is_help=False,
+    )
+    @staticmethod
+    def github_link(
+        token: Optional[str] = Option(
+            None,
+            "--token",
+            help="Manually provide a GitHub Personal Access Token instead of using OAuth flow."
+        ),
+        unlink: bool = Option(
+            False,
+            "--unlink",
+            help="Remove GitHub link and stored credentials."
+        ),
+        status: bool = Option(
+            False,
+            "--status", 
+            help="Check current GitHub link status."
+        )
+    ) -> None:
+        """Link GitHub for repository access."""
+
+        token_manager = GitHubTokenManager()
+
+        if unlink:
+            if token_manager.delete_token():
+                LinkSubCommand._progress_callback(
+                    "[green]✅ Successfully unlinked GitHub[/green]", "\n"
+                )
+            else:
+                LinkSubCommand._progress_callback(
+                    "[red]❌ Failed to remove GitHub link[/red]", "\n"
+                )
+            return
+
+        if status:
+            stored_token = token_manager.get_token()
+            if stored_token:
+                config = GitHubOAuthConfig()
+                device_flow = GitHubDeviceFlow(
+                    client_id=config.client_id,
+                    scopes=config.scopes,
+                    progress_callback=LinkSubCommand._progress_callback,
+                )
+                if device_flow.test_token(stored_token):
+                    LinkSubCommand._progress_callback(
+                        "[green]✅ GitHub link active[/green]", "\n"
+                    )
+                else:
+                    LinkSubCommand._progress_callback(
+                        "[red]❌ GitHub link invalid (token expired or revoked)[/red]",
+                        "\n",
+                    )
+            else:
+                LinkSubCommand._progress_callback(
+                    "[yellow]⚠️  GitHub not linked[/yellow]", "\n"
+                )
+            return
+
+        if token:
+            # Manual token input
+            config = GitHubOAuthConfig()
+            device_flow = GitHubDeviceFlow(
+                client_id=config.client_id,
+                scopes=config.scopes,
+                progress_callback=LinkSubCommand._progress_callback,
+            )
+            if device_flow.test_token(token):
+                if token_manager.store_token(token):
+                    LinkSubCommand._progress_callback(
+                        "[green]✅ GitHub token saved successfully[/green]", "\n"
+                    )
+                else:
+                    LinkSubCommand._progress_callback(
+                        "[red]❌ Failed to save token[/red]", "\n"
+                    )
+            else:
+                LinkSubCommand._progress_callback(
+                    "[red]❌ Invalid GitHub token[/red]", "\n"
+                )
+            return
+
+        # Device Flow - OAuth for CLIs
+        try:
+            LinkSubCommand._progress_callback(
+                "[blue]🔐 Starting GitHub Device Flow linking...[/blue]", "\n"
+            )
+
+            config = GitHubOAuthConfig()
+            device_flow = GitHubDeviceFlow(
+                client_id=config.client_id,
+                scopes=config.scopes,
+                progress_callback=LinkSubCommand._progress_callback,
+            )
+
+            access_token = device_flow.start_device_flow()
+
+            if access_token:
+                if token_manager.store_token(access_token):
+                    LinkSubCommand._progress_callback(
+                        "[green]✅ GitHub linked successfully![/green]", "\n"
+                    )
+                    LinkSubCommand._progress_callback(
+                        "🔑 Access token stored securely in keychain", "\n"
+                    )
+                    LinkSubCommand._progress_callback(
+                        "🚀 EasyRunner can now manage deploy keys for your repositories",
+                        "\n",
+                    )
+                else:
+                    LinkSubCommand._progress_callback(
+                        "[red]❌ Link succeeded but failed to store token[/red]",
+                        "\n",
+                    )
+            else:
+                LinkSubCommand._progress_callback(
+                    "[red]❌ GitHub linking failed[/red]", "\n"
+                )
+                LinkSubCommand._progress_callback(
+                    "💡 Try running the command again or use --token to manually provide a token",
+                    "\n",
+                )
+
+        except KeyboardInterrupt:
+            LinkSubCommand._progress_callback(
+                "\n[yellow]⚠️  Linking cancelled[/yellow]", "\n"
+            )
+        except Exception as e:
+            LinkSubCommand._progress_callback(
+                f"[red]❌ Linking error: {e}[/red]", "\n"
+            )
+            if LinkSubCommand.debug:
+                import traceback
+                LinkSubCommand._progress_callback(
+                    f"[red]{traceback.format_exc()}[/red]", "\n"
+                )
+
+    @typer_app.command(
+        name="status",
+        help="Show link status for all services.",
+        no_args_is_help=False,
+    )
+    @staticmethod
+    def link_status() -> None:
+        """Show link status for all services."""
+        LinkSubCommand._progress_callback(
+            "[bold blue]� Link Status[/bold blue]\n", "\n"
+        )
+
+        # Check GitHub
+        token_manager = GitHubTokenManager()
+        stored_token = token_manager.get_token()
+
+        if stored_token:
+            config = GitHubOAuthConfig()
+            device_flow = GitHubDeviceFlow(
+                client_id=config.client_id,
+                scopes=config.scopes,
+                progress_callback=LinkSubCommand._progress_callback,
+            )
+            if device_flow.test_token(stored_token):
+                LinkSubCommand._progress_callback(
+                    "GitHub: [green]✅ Linked[/green]", "\n"
+                )
+            else:
+                LinkSubCommand._progress_callback(
+                    "GitHub: [red]❌ Invalid (token expired or revoked)[/red]", "\n"
+                )
+        else:
+            LinkSubCommand._progress_callback(
+                "GitHub: [yellow]⚠️  Not linked[/yellow]", "\n"
+            )
+
+        LinkSubCommand._progress_callback(
+            "\n💡 Use 'er link github' to link GitHub", "\n"
+        )

easyrunner_cli-0.0.8.dev99/source/auth/github_device_flow.py

@@ -0,0 +1,247 @@
+"""GitHub Device Flow authentication for CLI applications.
+
+This module implements GitHub's Device Flow OAuth, which is designed for
+CLIs and doesn't require a client secret. Users authorize the app by
+visiting a URL and entering a code displayed in the terminal.
+"""
+
+import json
+import logging
+import time
+import webbrowser
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+from easyrunner.source.command_executor_local import CommandExecutorLocal
+from easyrunner.source.commands.ubuntu.curl_commands_ubuntu import CurlCommandsUbuntu
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DeviceCodeResponse:
+    """Response from device code request."""
+
+    device_code: str
+    user_code: str
+    verification_uri: str
+    expires_in: int
+    interval: int
+
+
+class GitHubDeviceFlow:
+    """GitHub Device Flow authentication for CLI applications."""
+
+    DEVICE_CODE_URL = "https://github.com/login/device/code"
+    TOKEN_URL = "https://github.com/login/oauth/access_token"
+
+    def __init__(
+        self,
+        client_id: str,
+        scopes: str = "repo",
+        progress_callback: Optional[Callable[[str, str], None]] = None,
+    ):
+        """Initialize device flow.
+
+        Args:
+            client_id: GitHub OAuth app client ID (public, safe to distribute)
+            scopes: OAuth scopes to request (default: "repo")
+            progress_callback: Optional callback for progress messages
+        """
+        self.client_id = client_id
+        self.scopes = scopes
+        self.executor = CommandExecutorLocal()
+        self.curl_commands = CurlCommandsUbuntu()
+        self.progress_callback = progress_callback or (lambda msg, end: None)
+
+    def start_device_flow(self) -> Optional[str]:
+        """Start device flow and return access token if successful."""
+        try:
+            # Step 1: Request device code
+            device_response = self._request_device_code()
+            if not device_response:
+                self.progress_callback(
+                    "[red]❌ Failed to request device code[/red]", "\n"
+                )
+                return None
+
+            # Step 2: Show user instructions
+            self._display_user_instructions(device_response)
+
+            # Step 3: Poll for token
+            return self._poll_for_token(device_response)
+
+        except Exception as e:
+            logger.error(f"Device flow failed: {e}")
+            self.progress_callback(f"[red]❌ Device flow failed: {e}[/red]", "\n")
+            return None
+
+    def _request_device_code(self) -> Optional[DeviceCodeResponse]:
+        """Request device code from GitHub."""
+        try:
+            request_data = {"client_id": self.client_id, "scope": self.scopes}
+
+            cmd = self.curl_commands.post(
+                url=self.DEVICE_CODE_URL,
+                data=json.dumps(request_data),
+                headers={
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
+                },
+            )
+
+            result = self.executor.execute(cmd)
+
+            if result.success and result.stdout:
+                response_body, _ = self.curl_commands.parse_curl_response_with_status(
+                    result.stdout
+                )
+                response_data = json.loads(response_body)
+
+                # Check for GitHub API errors
+                if "error" in response_data:
+                    error = response_data.get("error")
+                    error_desc = response_data.get("error_description", "Unknown error")
+                    logger.error(f"GitHub API error: {error} - {error_desc}")
+                    self.progress_callback(
+                        f"[red]❌ GitHub Error: {error_desc}[/red]", "\n"
+                    )
+                    if error == "device_flow_disabled":
+                        self.progress_callback(
+                            "[yellow]💡 Device Flow must be enabled in GitHub OAuth app settings[/yellow]",
+                            "\n",
+                        )
+                        self.progress_callback(
+                            "[yellow]   Visit: https://github.com/settings/developers[/yellow]",
+                            "\n",
+                        )
+                    return None
+
+                return DeviceCodeResponse(
+                    device_code=response_data["device_code"],
+                    user_code=response_data["user_code"],
+                    verification_uri=response_data["verification_uri"],
+                    expires_in=response_data["expires_in"],
+                    interval=response_data["interval"],
+                )
+
+            logger.error(f"Device code request failed: {result.stderr}")
+            return None
+
+        except Exception as e:
+            logger.error(f"Failed to request device code: {e}")
+            return None
+
+    def _display_user_instructions(self, device_response: DeviceCodeResponse) -> None:
+        """Display instructions to user."""
+        self.progress_callback("\n" + "=" * 60, "\n")
+        self.progress_callback("🔐 [bold cyan]GitHub Device Authorization[/bold cyan]", "\n")
+        self.progress_callback("=" * 60, "\n\n")
+        self.progress_callback(
+            f"1. Visit: [bold blue]{device_response.verification_uri}[/bold blue]",
+            "\n",
+        )
+        self.progress_callback(
+            f"2. Enter code: [bold yellow]{device_response.user_code}[/bold yellow]",
+            "\n\n",
+        )
+        self.progress_callback("🌐 Opening browser...", "\n")
+
+        # Auto-open browser
+        try:
+            webbrowser.open(device_response.verification_uri)
+        except Exception as e:
+            logger.warning(f"Failed to open browser: {e}")
+
+        self.progress_callback("\n⏳ Waiting for authorization", "")
+
+    def _poll_for_token(self, device_response: DeviceCodeResponse) -> Optional[str]:
+        """Poll GitHub for access token."""
+        interval = device_response.interval
+        expires_at = time.time() + device_response.expires_in
+        poll_count = 0
+
+        while time.time() < expires_at:
+            time.sleep(interval)
+
+            # Show progress dots
+            poll_count += 1
+            if poll_count % 3 == 0:
+                self.progress_callback(".", "")
+
+            token_data = {
+                "client_id": self.client_id,
+                "device_code": device_response.device_code,
+                "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+            }
+
+            cmd = self.curl_commands.post(
+                url=self.TOKEN_URL,
+                data=json.dumps(token_data),
+                headers={
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
+                },
+            )
+
+            result = self.executor.execute(cmd)
+
+            if result.success and result.stdout:
+                response_body, _ = self.curl_commands.parse_curl_response_with_status(
+                    result.stdout
+                )
+                response_data = json.loads(response_body)
+
+                # Success - token received
+                if "access_token" in response_data:
+                    self.progress_callback("\n", "\n")
+                    return response_data["access_token"]
+
+                # Handle errors
+                error = response_data.get("error")
+
+                if error == "authorization_pending":
+                    # Keep polling
+                    continue
+                elif error == "slow_down":
+                    # Increase interval as requested by GitHub
+                    interval += 5
+                    continue
+                elif error == "expired_token":
+                    self.progress_callback(
+                        "\n[red]❌ Device code expired. Please try again.[/red]", "\n"
+                    )
+                    return None
+                elif error == "access_denied":
+                    self.progress_callback(
+                        "\n[red]❌ Authorization denied by user.[/red]", "\n"
+                    )
+                    return None
+                else:
+                    logger.error(f"Unknown error during polling: {error}")
+                    self.progress_callback(
+                        f"\n[red]❌ Authorization failed: {error}[/red]", "\n"
+                    )
+                    return None
+
+        self.progress_callback("\n[red]❌ Authorization timed out.[/red]", "\n")
+        return None
+
+    def test_token(self, token: str) -> bool:
+        """Test if token is valid by making a test API call."""
+        try:
+            cmd = self.curl_commands.get(
+                url="https://api.github.com/user",
+                headers={"Authorization": f"Bearer {token}"},
+            )
+
+            result = self.executor.execute(cmd)
+            return (
+                result.success
+                and result.stdout is not None
+                and "login" in result.stdout
+            )
+
+        except Exception as e:
+            logger.error(f"Token validation failed: {e}")
+            return False

easyrunner_cli-0.0.8.dev99/source/auth/github_oauth_config.py

@@ -0,0 +1,24 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass
+class GitHubOAuthConfig:
+    """Configuration for GitHub OAuth (Device Flow).
+
+    Device Flow is designed for CLIs and doesn't require a client secret.
+    The client_id is public and safe to distribute in the codebase.
+    """
+    # Public client ID - safe to distribute
+    client_id: str = "Ov23liIBTV75Sjfu4Pay"
+    scopes: str = "repo"
+
+    # URLs for device flow
+    device_code_url: str = "https://github.com/login/device/code"
+    token_url: str = "https://github.com/login/oauth/access_token"
+
+    def __post_init__(self):
+        """Override client_id from env if present (for testing/development)."""
+        env_client_id = os.getenv("ER_GITHUB_OAUTH_CLIENT_ID")
+        if env_client_id:
+            self.client_id = env_client_id