easyrunner-cli 0.0.1.dev86__tar.gz

easyrunner_cli-0.0.1.dev86/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: easyrunner_cli
+Version: 0.0.1.dev86
+Summary: EasyRunner CLI.
+Author: Janaka Abeywardhana
+Author-email: contact@janaka.co.uk
+Requires-Python: >=3.13,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: cryptography (>=44.0.0,<45.0.0)
+Requires-Dist: keyring (>=25.6.0,<26.0.0)
+Requires-Dist: pyjwt (>=2.9.0,<3.0.0)
+Requires-Dist: pyobjc-framework-Security (>=10.3.1,<11.0.0) ; sys_platform == "darwin"
+Requires-Dist: rich (>=13.9.4,<14.0.0)
+Requires-Dist: typer (>=0.15.1,<0.16.0)
+Project-URL: Homepage, https://github.com/janaka/easyrunner
+Project-URL: Repository, https://github.com/janaka/easyrunner
+Description-Content-Type: text/markdown
+
+# EasyRunner CLI
+
+Application hosting platform that run on a single server.
+
+Copyright (c) 2024 - 2025 Janaka Abeywardhana
+
+## Contribution
+
+Setup python tools on a new machine
+
+- `brew install pyenv` - python virtual environment manager
+- `brew install pipx` - pipx python package manager, for install poetry
+- `pipx install poetry` (pipx installs global packages in isolated environments)
+- add `export PATH="$HOME/.local/bin:$PATH"` to ~/.zshrc for poetry.
+
+
+Setup python environment for an application
+
+- `pyenv install 3.13` install this version of python.
+- `pyenv local` show the version in this environment
+- `poetry env use $(pyenv which python)` to create a poetry environment in this project for dependencies. the `.venv`
+- `source $(poetry env info --path)/bin/activate` to activate the environment (avail on path etc.)
+- `poetry config virtualenvs.in-project true`
+- `poetry install`
+
+if the location of the repo changes on your local machine then the virtual env will get disconnected. Therefore remove and recreate
+
+- `poetry env remove $(poetry env list --full-path | grep -Eo '/.*')` Remove the current Poetry environment to force a clean rebuild:
+- `poetry install` Recreate the environment and install dependencies
+- `source $(poetry env info --path)/bin/activate` activate the environment

easyrunner_cli-0.0.1.dev86/README.md

@@ -0,0 +1,30 @@
+# EasyRunner CLI
+
+Application hosting platform that run on a single server.
+
+Copyright (c) 2024 - 2025 Janaka Abeywardhana
+
+## Contribution
+
+Setup python tools on a new machine
+
+- `brew install pyenv` - python virtual environment manager
+- `brew install pipx` - pipx python package manager, for install poetry
+- `pipx install poetry` (pipx installs global packages in isolated environments)
+- add `export PATH="$HOME/.local/bin:$PATH"` to ~/.zshrc for poetry.
+
+
+Setup python environment for an application
+
+- `pyenv install 3.13` install this version of python.
+- `pyenv local` show the version in this environment
+- `poetry env use $(pyenv which python)` to create a poetry environment in this project for dependencies. the `.venv`
+- `source $(poetry env info --path)/bin/activate` to activate the environment (avail on path etc.)
+- `poetry config virtualenvs.in-project true`
+- `poetry install`
+
+if the location of the repo changes on your local machine then the virtual env will get disconnected. Therefore remove and recreate
+
+- `poetry env remove $(poetry env list --full-path | grep -Eo '/.*')` Remove the current Poetry environment to force a clean rebuild:
+- `poetry install` Recreate the environment and install dependencies
+- `source $(poetry env info --path)/bin/activate` activate the environment

easyrunner_cli-0.0.1.dev86/easyrunner/cloud_providers/cloud_provider_base.py

@@ -0,0 +1,194 @@
+import os
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+import pulumi.automation as auto
+
+from ..tool_paths import EasyRunnerPaths
+from ..types.exec_result import ExecResult
+
+
+class CloudProviderBase(ABC):
+    """Base class for cloud provider implementations."""
+
+    def __init__(
+        self, api_key: str, region: str, project_name: Optional[str] = None
+    ) -> None:
+        self.api_key = api_key
+        self.region = region
+        self.project_name = project_name or f"easyrunner-{self.name()}"
+
+    @abstractmethod
+    def _create_provider(self) -> Any:
+        """Create the cloud provider instance."""
+        pass
+
+    def _get_pulumi_command(self) -> str:
+        """Get the Pulumi root directory for PulumiCommand, which will append /bin/pulumi."""
+        return str(EasyRunnerPaths.get_pulumi_root())
+
+    def _create_workspace_options(
+        self, backend_url: Optional[str] = None
+    ) -> auto.LocalWorkspaceOptions:
+        """Create workspace options with custom Pulumi command and optional backend."""
+        pulumi_command_path = self._get_pulumi_command()
+
+        # Set default backend to EasyRunner's local backend if not provided
+        if backend_url is None or backend_url == "":
+            backend_url = f"file://{EasyRunnerPaths.get_pulumi_local_backend_dir()}"
+
+        # Set Pulumi config passphrase if not already set
+        if "PULUMI_CONFIG_PASSPHRASE" not in os.environ:
+            os.environ["PULUMI_CONFIG_PASSPHRASE"] = (
+                "klshdf324£$@::D£$mcmoWERXakhk234%basdmnbqqvffadqWEQAO[]£N!#sdff"
+            )
+
+        return auto.LocalWorkspaceOptions(
+            pulumi_command=auto.PulumiCommand(pulumi_command_path),
+            pulumi_home=str(
+                EasyRunnerPaths.get_pulumi_root()
+            ),  # Control where all Pulumi data is stored
+            secrets_provider="passphrase",
+            work_dir=str(
+                EasyRunnerPaths.get_pulumi_local_backend_dir()
+            ),  # Set workspace directory
+            project_settings=auto.ProjectSettings(
+                name=self.project_name,
+                runtime="python",
+                backend=auto.ProjectBackend(url=backend_url),
+            ),
+        )
+
+    def _ensure_cloud_tools_available(self) -> ExecResult:
+        """Ensure cloud tools are available before executing Pulumi operations."""
+        from easyrunner_cli.source.infrastructure_deps import InfrastructureDependencies
+
+        return InfrastructureDependencies.ensure_cloud_tools_available()
+
+    def get_provider_instance(self) -> Any:
+        """Get the provider instance for programmatic use."""
+
+        return self._create_provider()
+
+    def _convert_pulumi_outputs_to_dict(
+        self, outputs: auto.OutputMap
+    ) -> dict[str, Any]:
+        """Convert Pulumi OutputMap to standard dictionary with extracted values.
+
+        Args:
+            outputs: Pulumi OutputMap from stack.outputs()
+
+        Returns:
+            Dictionary with extracted values from Pulumi OutputValue objects
+        """
+        result: dict[str, Any] = {}
+        for key, output_value in outputs.items():
+            # Pulumi automation API returns OutputValue objects with a 'value' field
+            result[key] = (
+                output_value.value if hasattr(output_value, "value") else output_value
+            )
+        return result
+
+    @abstractmethod
+    def name(self) -> str:
+        """Get the name of the cloud provider."""
+        pass
+
+    # def execute_pulumi_program(
+    #     self,
+    #     program: Callable[[], None],
+    #     stack_name: str,
+    #     backend_url: Optional[str] = None,
+    # ) -> ExecResult:
+    #     """Execute a Pulumi program using EasyRunner's Pulumi installation.
+
+    #     Args:
+    #         program: The Pulumi program function to execute
+    #         stack_name: Name of the stack
+    #         backend_url: Optional backend URL (e.g., s3://bucket-name for S3 backend)
+    #     Returns:
+    #         ExecResult[dict[str, Any]]: The result of the Pulumi program execution stack.outputs as a dictionary.
+    #     """
+    #     # Ensure cloud tools are available before executing
+    #     deps_result = self._ensure_cloud_tools_available()
+    #     if not deps_result.success:
+    #         return deps_result
+
+    #     try:
+    #         # Create or select stack with custom workspace options
+    #         stack = auto.create_or_select_stack(
+    #             stack_name=stack_name,
+    #             project_name=self.project_name,
+    #             program=program,
+    #             opts=self._create_workspace_options(backend_url=backend_url),
+    #         )
+
+    #         # Deploy
+    #         stack.up()
+
+    #         result = ExecResult[dict[str, Any]](
+    #             success=True,
+    #             return_code=0,
+    #             stdout="Stack deployed successfully",
+    #             stderr=None,
+    #         )
+
+    #         # Convert Pulumi OutputMap to standard dict
+    #         result.result = self._convert_pulumi_outputs_to_dict(stack.outputs())
+
+    #         return result
+
+    #     except Exception as e:
+    #         return ExecResult(success=False, return_code=1, stdout=None, stderr=str(e))
+
+    # def destroy_pulumi_stack(
+    #     self, stack_name: str, backend_url: Optional[str] = None
+    # ) -> ExecResult:
+    #     """Destroy a Pulumi stack using EasyRunner's Pulumi installation."""
+    #     try:
+
+    #         def dummy_program() -> None:
+    #             """Empty program required for stack selection."""
+    #             pass
+
+    #         stack = auto.select_stack(
+    #             stack_name=stack_name,
+    #             project_name=self.project_name,
+    #             program=dummy_program,
+    #             opts=self._create_workspace_options(backend_url=backend_url),
+    #         )
+
+    #         stack.destroy()
+
+    #         return ExecResult(
+    #             success=True,
+    #             return_code=0,
+    #             stdout=f"Stack {stack_name} destroyed",
+    #             stderr=None,
+    #         )
+
+    #     except Exception as e:
+    #         return ExecResult(success=False, return_code=1, stdout=None, stderr=str(e))
+
+    def get_stack_outputs(
+        self, stack_name: str, backend_url: Optional[str] = None
+    ) -> Optional[dict[str, Any]]:
+        """Get outputs from a Pulumi stack using EasyRunner's Pulumi installation."""
+        try:
+            stack = auto.select_stack(
+                stack_name=stack_name,
+                project_name=self.project_name,
+                opts=self._create_workspace_options(backend_url=backend_url),
+            )
+
+            outputs = stack.outputs()
+            result = self._convert_pulumi_outputs_to_dict(outputs)
+            return result if result else None
+
+        except Exception:
+            return None
+
+    # @abstractmethod
+    # def create_select_state_backend_bucket(self) -> ExecResult:
+    #     """Setup the Pulumi state backend."""
+    #     pass

easyrunner_cli-0.0.1.dev86/easyrunner/cloud_providers/cloud_providers.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class CloudProviders(str, Enum):
+    """Supported cloud providers for automated server creation."""
+    #AZURE = "azure"
+    #AWS = "aws"
+    #DIGITAL_OCEAN = "digitalocean"
+    #LINODE = "linode"
+    #VULTR = "vultr"
+    HETZNER = "hetzner"
+    #GCP = "gcp"
+    #OVH = "ovh"
+    

easyrunner_cli-0.0.1.dev86/easyrunner/cloud_providers/hetzner_provider.py

@@ -0,0 +1,77 @@
+import os
+from typing import TYPE_CHECKING
+
+from .cloud_provider_base import CloudProviderBase
+from .cloud_providers import CloudProviders
+
+if TYPE_CHECKING:
+    import pulumi_hcloud
+
+
+class HetznerProvider(CloudProviderBase):
+    """Hetzner cloud provider implementation using Pulumi."""
+
+    def __init__(self, api_key: str, region: str = "nbg1"):
+        super().__init__(api_key, region)
+        # Store the API key for programmatic provider configuration
+        self._hetzner_token = api_key
+
+    def _create_provider(self) -> "pulumi_hcloud.Provider":
+        """Create Hetzner provider with explicit token configuration."""
+        import pulumi_hcloud as hetzner
+
+        return hetzner.Provider("hetzner-provider", token=self._hetzner_token)
+
+    def name(self) -> str:
+        """Get the name of the cloud provider."""
+        return CloudProviders.HETZNER.value
+
+    @classmethod
+    def from_env(cls, region: str = "nbg1") -> "HetznerProvider":
+        """Create HetznerProvider instance from HETZNER_API_KEY environment variable."""
+        api_key = os.getenv("HETZNER_API_KEY")
+        if not api_key:
+            raise ValueError("HETZNER_API_KEY environment variable is required")
+        return cls(api_key=api_key, region=region)
+
+    # def create_select_state_backend_bucket(self) -> ExecResult:
+    #     """Setup Pulumi state backend - local for initial setup, S3 for production.
+
+    #     Retrurns:
+    #         ExecResult[dict[str, Any]]
+
+    #         results keys:
+    #             - bucket_name: Name of the created S3 bucket for state storage.
+    #     """
+
+    #     # Create S3 compatible object storage backend using the base class execute_pulumi_program method
+    #     def create_state_backend_object_store() -> None:
+    #         """there currently no pulumi object storage support for Hetzner as it's a new service."""
+    #         pass
+
+    #     # Execute the program using local backend (for creating the S3 bucket)
+    #     result: ExecResult[dict[str, Any]] = self.execute_pulumi_program(
+    #         program=create_state_backend_object_store,
+    #         stack_name="state-backend",
+    #         backend_url=None,  # Use local backend to create the S3 bucket
+    #     )
+
+    #     if not result.success:
+    #         return result
+
+    #     # Get the bucket name from outputs
+    #     outputs = self.get_stack_outputs(
+    #         stack_name="state-backend",
+    #         backend_url=None,
+    #     )
+
+    #     bucket_name = ""
+    #     if outputs and "state_bucket_name" in outputs:
+    #         bucket_name = outputs["state_bucket_name"]
+
+    #     return ExecResult(
+    #         success=True,
+    #         return_code=0,
+    #         stdout=f"S3 state bucket created: {bucket_name}. Use backend URL: s3://{bucket_name}",
+    #         stderr=None,
+    #     )

easyrunner_cli-0.0.1.dev86/easyrunner/command_executor.py

@@ -0,0 +1,99 @@
+import logging
+from io import BytesIO
+from pathlib import Path
+
+from fabric import Result as InvokeResult
+from fabric.transfer import Result as TransferResult
+
+from .commands.runnable_command_string import RunnableCommandString
+from .ssh import Ssh
+from .types.exec_result import ExecResult
+
+
+class CommandExecutor:
+    """This class is responsible for executing commands on the remote machine"""
+    def __init__(self, ssh_client: Ssh):
+        # setup logger for this class with correct logger namespace hierarchy
+        self._logger: logging.Logger = logging.getLogger(__name__)
+        # Critical for libs to prevent log messages from propagating to the root logger and causing dup logs and config issues.
+        self._logger.addHandler(logging.NullHandler())
+
+        self.ssh_client: Ssh = ssh_client
+
+    def execute(self, command: RunnableCommandString) -> ExecResult:
+        """
+        Execute a command on the remote host.
+
+        Args:
+            command: Command to execute
+        """
+
+        if command.output_to_file is not None:
+            redirect_operator = ">>" if command.append_or_overwrite == "APPEND" else ">"
+            command = RunnableCommandString(
+                command=f"{command.command} {redirect_operator} {command.output_to_file}"
+            )
+
+        with self.ssh_client as ssh:
+            result: InvokeResult = (
+                ssh.run_sudo(command=command)
+                if command.sudo
+                else ssh.run(command=command)
+            )
+            mapped_result = self._map_invoke_result(result, command=command)
+
+            self._logger.debug(
+                "Command Executed > '%r', On Remote Host: '%s:%s'\n\n",
+                mapped_result,
+                ssh.hostname,
+                ssh.port,
+            )
+            return mapped_result
+
+    def put_file(self, source: Path | str | BytesIO, remote_path: str) -> ExecResult:
+        """
+        Transfer a file from local machine where this method is executed to remote host.
+
+        See https://docs.fabfile.org/en/latest/api/transfer.html#fabric.transfer.Transfer.put
+        Args:
+            local_path: Path to local file or a file-like object as io.StringIO(content_str).
+            remote_path: Remote destination path
+        """
+        try:
+            with self.ssh_client as ssh:
+                self._logger.debug(
+                    "Transferring file to remote host. Remote path: '%s'",
+                    remote_path,
+                )
+                result: TransferResult = ssh.connection.put(
+                    local=source, remote=remote_path, preserve_mode=False
+                )
+
+                return ExecResult(
+                    stdout=f"Transferring file '{result.local}' to remote '{result.remote}' successfully",
+                    return_code=0,
+                    success=True,
+                )
+
+        except Exception as e:
+            return ExecResult(
+                stdout="",
+                stderr=str(e),
+                return_code=1,
+                success=False,
+            )
+
+            # raise RuntimeError(
+            #     f"CommandExecutor.put_file() - Failed to transfer file to remote host: {str(e)}"
+            # )
+
+    def _map_invoke_result(
+        self, result: InvokeResult, command: RunnableCommandString
+    ) -> ExecResult:
+        return ExecResult(
+            stdout=result.stdout,
+            stderr=result.stderr,
+            return_code=result.return_code,
+            success=result.return_code == 0,
+            command=command,
+        )

easyrunner_cli-0.0.1.dev86/easyrunner/command_executor_local.py

@@ -0,0 +1,150 @@
+import logging
+from io import BytesIO
+from pathlib import Path
+
+from invoke import run
+from invoke.runners import Result as InvokeResult
+
+from .commands.runnable_command_string import RunnableCommandString
+from .types.exec_result import ExecResult
+
+
+class CommandExecutorLocal:
+    """ This class is responsible for executing commands on the local machine"""
+    def __init__(self, debug: bool = False, silent: bool = True):
+        # setup logger for this class with correct logger namespace hierarchy
+        self._logger: logging.Logger = logging.getLogger(__name__)
+        # Critical for libs to prevent log messages from propagating to the root logger and causing dup logs and config issues.
+        self._logger.addHandler(logging.NullHandler())
+
+        self.debug: bool = debug
+        self.silent: bool = silent
+
+        # Configure hide behavior like your SSH class
+        if self.debug:
+            self._hide: bool | str = False
+        elif self.silent:
+            self._hide = "both"
+        else:
+            # self._hide = False
+            self._hide = "both"
+
+    def execute(self, command: RunnableCommandString) -> ExecResult:
+        """
+        Execute a command on the local machine.
+
+        Args:
+            command: Command to execute
+        """
+
+        if command.output_to_file is not None:
+            redirect_operator = ">>" if command.append_or_overwrite == "APPEND" else ">"
+            command = RunnableCommandString(
+                command=f"{command.command} {redirect_operator} {command.output_to_file}"
+            )
+
+        # Build the actual command to execute
+        cmd = f"sudo {command.command}" if command.sudo else command.command
+
+        try:
+            result: InvokeResult | None = run(
+                command=cmd,
+                env=command.env,
+                hide=self._hide,
+                warn=True  # Don't raise on non-zero exit codes
+            )
+            mapped_result = self._map_invoke_result(result, command=command)
+
+            self._logger.debug(
+                "Command Executed > '%r', On Local Machine\n\n",
+                mapped_result,
+            )
+            return mapped_result
+        except Exception as e:
+            self._logger.error(
+                "Command didn't reach an exit code. Command: %s", cmd
+            )
+            return ExecResult(
+                stdout="",
+                stderr=str(e),
+                return_code=1,
+                success=False,
+                command=command,
+            )
+
+    def put_file(self, source: Path | str | BytesIO, remote_path: str) -> ExecResult:
+        """
+        Copy a file locally from source to destination.
+
+        Args:
+            source: Path to source file or a file-like object as BytesIO.
+            remote_path: Local destination path
+        """
+        try:
+            dest_path = Path(remote_path)
+
+            # Create parent directories if they don't exist
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+
+            if isinstance(source, (str, Path)):
+                # Copy from file path
+                source_path = Path(source)
+                if not source_path.exists():
+                    return ExecResult(
+                        stdout="",
+                        stderr=f"Source file does not exist: {source}",
+                        return_code=1,
+                        success=False,
+                    )
+
+                import shutil
+                shutil.copy2(source_path, dest_path)
+                self._logger.debug(
+                    "File copied locally from '%s' to '%s'",
+                    source_path,
+                    dest_path,
+                )
+
+            elif isinstance(source, BytesIO):
+                # Write from BytesIO object
+                with open(dest_path, 'wb') as f:
+                    f.write(source.getvalue())
+                self._logger.debug(
+                    "Content written to file '%s' from BytesIO object",
+                    dest_path,
+                )
+
+            return ExecResult(
+                stdout=f"File copied successfully from '{source}' to '{dest_path}'",
+                stderr="",
+                return_code=0,
+                success=True,
+            )
+
+        except Exception as e:
+            return ExecResult(
+                stdout="",
+                stderr=str(e),
+                return_code=1,
+                success=False,
+            )
+
+    def _map_invoke_result(
+        self, result: InvokeResult | None, command: RunnableCommandString
+    ) -> ExecResult:
+        if result is None:
+            return ExecResult(
+                stdout="",
+                stderr="InvokeResult was None",
+                return_code=1,
+                success=False,
+                command=command,
+            )
+
+        return ExecResult(
+            stdout=result.stdout or "",
+            stderr=result.stderr or "",
+            return_code=result.return_code,
+            success=result.return_code == 0,
+            command=command,
+        )

easyrunner_cli-0.0.1.dev86/easyrunner/commands/__init__.py

@@ -0,0 +1,15 @@
+# from .base.caddy_commands import CaddyCommands
+# from .base.command_base import CommandBase
+# from .base.docker_compose_commands import DockerComposeCommands
+# from .base.git_commands import GitCommands
+# from .base.os_package_manager_commands import OsPackageManagerCommands
+# from .base.podman_commands import PodmanCommands
+
+# __all__ = [
+#     "CaddyCommands",
+#     "CommandBase",
+#     "DockerComposeCommands",
+#     "PodmanCommands",
+#     "GitCommands",
+#     "OsPackageManagerCommands",
+# ]

easyrunner_cli-0.0.1.dev86/easyrunner/commands/base/__init__.py

@@ -0,0 +1,39 @@
+from .archive_commands import ArchiveCommands
+from .caddy_api_curl_commands import CaddyApiCurlCommands
+from .caddy_commands import CaddyCommands
+from .command_base import CommandBase
+from .curl_commands import CurlCommands
+from .dir_commands import DirCommands
+from .docker_compose_commands import DockerComposeCommands
+from .file_commands import FileCommands
+from .git_commands import GitCommands
+from .ip_tables_commands import IpTablesCommands
+from .ip_tables_persistent_commands import IpTablesPersistentCommands
+from .null_command import NullCommand
+from .os_package_manager_commands import OsPackageManagerCommands
+from .podman_commands import PodmanCommands
+from .ssh_agent_commands import SshAgentCommands
+from .ssh_keygen_commands import SshKeygenCommands
+from .systemctl_commands import SystemctlCommands
+from .utility_commands import UtilityCommands
+
+__all__ = [
+    "ArchiveCommands",
+    "CaddyApiCurlCommands",
+    "CaddyCommands",
+    "CommandBase",
+    "CurlCommands",
+    "DirCommands",
+    "DockerComposeCommands",
+    "FileCommands",
+    "GitCommands",
+    "IpTablesCommands",
+    "IpTablesPersistentCommands",
+    "NullCommand",
+    "OsPackageManagerCommands",
+    "PodmanCommands",
+    "SshAgentCommands",
+    "SystemctlCommands",
+    "UtilityCommands",
+    "SshKeygenCommands",
+]