toast-cli 3.0.0.dev0__py3-none-any.whl

toast/__init__.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+
+import click
+import importlib
+import inspect
+import os
+import pkgutil
+import sys
+from typing import List, Type
+from toast.helpers import CustomHelpGroup
+
+def discover_and_load_plugins(plugins_package_name: str = "toast.plugins") -> List[Type]:
+    """
+    Dynamically discover and load all plugin classes from the plugins package.
+
+    Args:
+        plugins_package_name: Name of the plugins package to search
+
+    Returns:
+        List of plugin classes that extend BasePlugin
+    """
+    from toast.plugins.base_plugin import BasePlugin
+
+    discovered_plugins = []
+
+    try:
+        # Import the plugins package
+        plugins_package = importlib.import_module(plugins_package_name)
+        plugins_path = os.path.dirname(plugins_package.__file__)
+
+        # Discover all modules in the plugins package
+        for _, name, is_pkg in pkgutil.iter_modules([plugins_path]):
+            # Skip the base_plugin module and __init__.py
+            if name == "base_plugin" or name == "__init__" or name == "utils":
+                continue
+
+            # Import the module
+            module_name = f"{plugins_package_name}.{name}"
+            try:
+                module = importlib.import_module(module_name)
+
+                # Find all classes in the module that are subclasses of BasePlugin
+                for item_name, item in inspect.getmembers(module, inspect.isclass):
+                    if (issubclass(item, BasePlugin) and
+                        item is not BasePlugin and
+                        item.__module__ == module_name):
+                        discovered_plugins.append(item)
+            except ImportError as e:
+                click.echo(f"Error loading plugin module {module_name}: {e}", err=True)
+
+    except ImportError as e:
+        click.echo(f"Error loading plugins package {plugins_package_name}: {e}", err=True)
+
+    return discovered_plugins
+
+
+@click.group(cls=CustomHelpGroup)
+def toast_cli():
+    """
+    Toast command-line tool with dynamically loaded plugins.
+    """
+    pass
+
+def main():
+    # Discover and load all plugins
+    plugins = discover_and_load_plugins()
+
+    if not plugins:
+        click.echo("No plugins were discovered", err=True)
+        sys.exit(1)
+
+    # Register each plugin with the CLI
+    for plugin_class in plugins:
+        try:
+            plugin_class.register(toast_cli)
+        except Exception as e:
+            click.echo(f"Error registering plugin {plugin_class.__name__}: {e}", err=True)
+
+    # Run the CLI
+    toast_cli()
+
+if __name__ == "__main__":
+    main()

toast/__main__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+
+from toast import main
+
+if __name__ == "__main__":
+    main()

toast/helpers.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+
+import click
+import os
+
+def display_logo():
+    """Display the toast.sh ASCII logo"""
+    logo = """
+ _                  _         _
+| |_ ___   __ _ ___| |_   ___| |__
+| __/ _ \ / _' / __| __| / __| '_ \\
+| || (_) | (_| \__ \ |_ _\__ \ | | |
+ \__\___/ \__,_|___/\__(-)___/_| |_|   v{0}
+""".format(get_version())
+    click.echo(logo)
+    click.echo("=" * 80)
+
+def get_version():
+    """Get the version from the VERSION file"""
+    try:
+        version_file = os.path.join(os.path.dirname(__file__), "..", "VERSION")
+        if os.path.exists(version_file):
+            with open(version_file, "r") as f:
+                version = f.read().strip()
+                return version
+        return "3.0.0"
+    except Exception:
+        return "3.0.0"
+
+class CustomHelpCommand(click.Command):
+    def get_help(self, ctx):
+        display_logo()
+        return super().get_help(ctx)
+
+class CustomHelpGroup(click.Group):
+    def get_help(self, ctx):
+        display_logo()
+        return super().get_help(ctx)

toast/plugins/__init__.py

@@ -0,0 +1 @@
+# Make the plugins directory a Python package

toast/plugins/am_plugin.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+
+import click
+import subprocess
+from toast.plugins.base_plugin import BasePlugin
+
+class AmPlugin(BasePlugin):
+    """Plugin for 'am' command - shows AWS caller identity."""
+
+    name = "am"
+    help = "Show AWS caller identity"
+
+    @classmethod
+    def execute(cls, **kwargs):
+        try:
+            result = subprocess.run(["aws", "sts", "get-caller-identity"], capture_output=True, text=True)
+            if result.returncode == 0:
+                formatted_json = subprocess.run(["jq", "-C", "."], input=result.stdout, capture_output=True, text=True)
+                click.echo(formatted_json.stdout)
+            else:
+                click.echo("Error fetching AWS caller identity.")
+        except Exception as e:
+            click.echo(f"Error fetching AWS caller identity: {e}")

toast/plugins/base_plugin.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+
+import click
+
+class BasePlugin:
+    """Base class for all plugins."""
+
+    name = None  # Command name
+    help = None  # Command help text
+
+    @classmethod
+    def register(cls, cli_group):
+        """Register the plugin with the CLI group."""
+        if not cls.name:
+            raise ValueError(f"Plugin {cls.__name__} must define a name")
+
+        # Use regular Command class to avoid showing logo for subcommands
+        @cli_group.command(name=cls.name, help=cls.help, cls=click.Command)
+        @cls.get_arguments
+        def command(**kwargs):
+            return cls.execute(**kwargs)
+
+    @classmethod
+    def get_arguments(cls, func):
+        """Define command arguments. Override in subclass."""
+        return func
+
+    @classmethod
+    def execute(cls, **kwargs):
+        """Execute the command. Override in subclass."""
+        raise NotImplementedError(f"Plugin {cls.__name__} must implement execute method")

toast/plugins/cdw_plugin.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+
+import click
+import subprocess
+import os
+from toast.plugins.base_plugin import BasePlugin
+from toast.plugins.utils import select_from_list
+
+class CdwPlugin(BasePlugin):
+    """Plugin for 'cdw' command - helps navigate to workspace directories."""
+
+    name = "cdw"
+    help = "Navigate to a workspace directory"
+
+    @classmethod
+    def execute(cls, **kwargs):
+        workspace_dir = os.path.expanduser("~/workspace")
+        if not os.path.exists(workspace_dir):
+            os.makedirs(workspace_dir)
+
+        result = subprocess.run(["find", workspace_dir, "-mindepth", "1", "-maxdepth", "2", "-type", "d"], capture_output=True, text=True)
+        directories = sorted(result.stdout.splitlines())
+
+        if not directories:
+            click.echo("No directories found in ~/workspace.")
+            return
+
+        selected_dir = select_from_list(directories, "Select a directory")
+
+        if selected_dir:
+            click.echo(selected_dir)
+        else:
+            click.echo("No directory selected.", err=True)

toast/plugins/ctx_plugin.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+import click
+import subprocess
+from toast.plugins.base_plugin import BasePlugin
+from toast.plugins.utils import select_from_list
+
+class CtxPlugin(BasePlugin):
+    """Plugin for 'ctx' command - manages Kubernetes contexts."""
+
+    name = "ctx"
+    help = "Manage Kubernetes contexts"
+
+    @classmethod
+    def execute(cls, **kwargs):
+        result = subprocess.run(["kubectl", "config", "get-contexts", "-o=name"], capture_output=True, text=True)
+        if result.returncode != 0:
+            click.echo("Error fetching Kubernetes contexts. Is kubectl configured correctly?")
+            return
+
+        contexts = sorted(result.stdout.splitlines())
+        contexts.append("[New...]")
+        if len(contexts) > 1:
+            contexts.append("[Del...]")
+
+        selected_ctx = select_from_list(contexts, "Select a Kubernetes context")
+
+        if selected_ctx == "[New...]":
+            result = subprocess.run(["aws", "eks", "list-clusters", "--query", "clusters", "--output", "text"], capture_output=True, text=True)
+            if result.returncode != 0:
+                click.echo("Error fetching EKS clusters.")
+                return
+
+            clusters = sorted(result.stdout.split())
+            if not clusters:
+                click.echo("No EKS clusters found.")
+                return
+
+            selected_cluster = select_from_list(clusters, "Select an EKS cluster")
+
+            if selected_cluster:
+                subprocess.run(["aws", "eks", "update-kubeconfig", "--name", selected_cluster, "--alias", selected_cluster])
+                click.echo(f"Updated kubeconfig for {selected_cluster}")
+            else:
+                click.echo("No cluster selected.")
+        elif selected_ctx == "[Del...]":
+            delete_contexts = [ctx for ctx in contexts if ctx not in ("[New...]", "[Del...]")]
+            delete_contexts.append("[All...]")
+            selected_to_delete = select_from_list(delete_contexts, "Select a context to delete")
+            if selected_to_delete == "[All...]":
+                subprocess.run(["kubectl", "config", "unset", "contexts"])
+                click.echo("Deleted all Kubernetes contexts.")
+            elif selected_to_delete:
+                subprocess.run(["kubectl", "config", "delete-context", selected_to_delete])
+                click.echo(f"Deleted Kubernetes context: {selected_to_delete}")
+            else:
+                click.echo("No context selected for deletion.")
+        elif selected_ctx:
+            subprocess.run(["kubectl", "config", "use-context", selected_ctx])
+            click.echo(f"Switched to Kubernetes context: {selected_ctx}")
+        else:
+            click.echo("No context selected.")

toast/plugins/env_plugin.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+
+import click
+import subprocess
+import os
+import dotenv
+from pathlib import Path
+from toast.plugins.base_plugin import BasePlugin
+from toast.plugins.utils import select_from_list
+
+class EnvPlugin(BasePlugin):
+    """Plugin for 'env' command - sets environment."""
+
+    name = "env"
+    help = "Set environment with AWS profile"
+
+    @classmethod
+    def get_arguments(cls, func):
+        func = click.argument('env_name', required=False)(func)
+        return func
+
+    @classmethod
+    def execute(cls, env_name=None, **kwargs):
+        # Try to get AWS_ENV_PATH from .env file
+        dotenv_path = Path('.env')
+        env_path = None
+
+        if dotenv_path.exists():
+            dotenv.load_dotenv(dotenv_path)
+            env_path = os.environ.get("AWS_ENV_PATH")
+
+        # If AWS_ENV_PATH is not set, create it
+        if not env_path:
+            # Get username using whoami command
+            result = subprocess.run(["whoami"], capture_output=True, text=True)
+            default_username = result.stdout.strip()
+
+            # Create github.com directory if it doesn't exist
+            github_dir = os.path.expanduser("~/workspace/github.com")
+            if not os.path.exists(github_dir):
+                os.makedirs(github_dir, exist_ok=True)
+                click.echo(f"Created directory: {github_dir}")
+
+            # Ask user to input username or use provided env_name as username
+            if not env_name:
+                click.echo(f"Enter GitHub username (default: {default_username}):")
+                input_username = input().strip()
+                username = input_username if input_username else default_username
+            else:
+                # Check if env_name might be a profile name rather than username
+                potential_path = os.path.expanduser(f"~/workspace/github.com/{default_username}/keys/env/{env_name}")
+                if os.path.exists(potential_path):
+                    # env_name is likely a profile name, use default username
+                    username = default_username
+                else:
+                    # env_name is likely a username
+                    username = env_name
+
+            # Set AWS_ENV_PATH
+            env_path = os.path.expanduser(f"~/workspace/github.com/{username}/keys/env")
+
+            # Create directory if it doesn't exist
+            env_dir = os.path.dirname(env_path)
+            if not os.path.exists(env_dir):
+                os.makedirs(env_dir, exist_ok=True)
+                click.echo(f"Created directory: {env_dir}")
+
+            # Update .env file
+            with open(dotenv_path, 'a+') as f:
+                f.seek(0)
+                content = f.read()
+                if "AWS_ENV_PATH" not in content:
+                    if content and not content.endswith('\n'):
+                        f.write('\n')
+                    f.write(f"AWS_ENV_PATH={env_path}\n")
+
+            # Export the environment variable
+            os.environ["AWS_ENV_PATH"] = env_path
+
+        # List available profiles if env_path exists
+        if os.path.exists(env_path):
+            try:
+                profiles = [f for f in os.listdir(env_path) if os.path.isfile(os.path.join(env_path, f))]
+
+                if not profiles:
+                    click.echo(f"No profiles found in {env_path}")
+                    return
+
+                if not env_name or env_name not in profiles:
+                    selected_profile = select_from_list(profiles, "Select an AWS profile")
+                    if selected_profile:
+                        env_name = selected_profile
+                    else:
+                        click.echo("No profile selected.")
+                        return
+
+                # Load the selected profile and environment variables
+                profile_path = os.path.join(env_path, env_name)
+                aws_access_key_id = None
+                aws_secret_access_key = None
+                aws_region = None
+
+                if os.path.exists(profile_path):
+                    with open(profile_path, 'r') as f:
+                        for line in f:
+                            if '=' in line:
+                                key, value = line.strip().split('=', 1)
+                                os.environ[key] = value
+
+                                # Capture AWS credentials for config file
+                                if key == "AWS_ACCESS_KEY_ID":
+                                    aws_access_key_id = value
+                                elif key == "AWS_SECRET_ACCESS_KEY":
+                                    aws_secret_access_key = value
+                                elif key == "AWS_REGION":
+                                    aws_region = value
+
+                # Ensure AWS CLI config directory exists
+                aws_config_dir = os.path.expanduser("~/.aws")
+                if not os.path.exists(aws_config_dir):
+                    os.makedirs(aws_config_dir, exist_ok=True)
+
+                # Update AWS config and credentials files if we have the necessary info
+                if aws_access_key_id and aws_secret_access_key:
+                    # Update credentials file for both profile name and default
+                    credentials_file = os.path.join(aws_config_dir, "credentials")
+
+                    # Update the named profile
+                    cls._update_aws_file(credentials_file, env_name, {
+                        "aws_access_key_id": aws_access_key_id,
+                        "aws_secret_access_key": aws_secret_access_key
+                    })
+
+                    # Also update default profile with the same credentials
+                    cls._update_aws_file(credentials_file, "default", {
+                        "aws_access_key_id": aws_access_key_id,
+                        "aws_secret_access_key": aws_secret_access_key
+                    })
+
+                    click.echo(f"Updated default AWS profile with {env_name} credentials")
+
+                    # Update config file for both profile name and default
+                    config_file = os.path.join(aws_config_dir, "config")
+                    config_entries = {}
+                    if aws_region:
+                        config_entries["region"] = aws_region
+
+                    if config_entries:
+                        # Update the named profile
+                        cls._update_aws_file(config_file, f"profile {env_name}", config_entries)
+
+                        # Also update default profile
+                        cls._update_aws_file(config_file, "default", config_entries)
+
+                # Set the AWS_PROFILE environment variable
+                os.environ["AWS_PROFILE"] = env_name
+                click.echo(f"Set AWS_PROFILE={env_name}")
+
+                click.echo(f"Set environment to {env_name}")
+
+                # Display region if available
+                if "AWS_REGION" in os.environ:
+                    click.echo(f"AWS Region: {os.environ['AWS_REGION']}")
+
+                # Display profile information using AWS CLI with colored output
+                try:
+                    result = subprocess.run(["aws", "sts", "get-caller-identity"], capture_output=True, text=True)
+                    if result.returncode == 0:
+                        formatted_json = subprocess.run(["jq", "-C", "."], input=result.stdout, capture_output=True, text=True)
+                        click.echo(formatted_json.stdout)
+                    else:
+                        click.echo("Error fetching AWS caller identity.")
+                except Exception as e:
+                    click.echo(f"Error fetching AWS identity: {e}")
+
+            except Exception as e:
+                click.echo(f"Error setting environment: {e}")
+        else:
+            click.echo(f"Environment path does not exist: {env_path}")
+
+    @staticmethod
+    def _update_aws_file(file_path, section_name, entries):
+        """Update AWS credentials or config file with given section and entries"""
+        config_content = ""
+        section_exists = False
+
+        # Read existing content if file exists
+        if os.path.exists(file_path):
+            with open(file_path, 'r') as f:
+                config_content = f.read()
+
+        # Parse sections
+        sections = {}
+        current_section = None
+        for line in config_content.splitlines():
+            line = line.strip()
+            if line.startswith('[') and line.endswith(']'):
+                current_section = line[1:-1]
+                sections[current_section] = []
+            elif current_section is not None:
+                sections[current_section].append(line)
+
+        # Update or add section
+        sections[section_name] = [f"{key} = {value}" for key, value in entries.items()]
+
+        # Write updated content
+        with open(file_path, 'w') as f:
+            for section, lines in sections.items():
+                f.write(f"[{section}]\n")
+                for line in lines:
+                    f.write(f"{line}\n")
+                f.write("\n")  # Empty line between sections

toast/plugins/git_plugin.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+
+import click
+import os
+import subprocess
+import re
+from toast.plugins.base_plugin import BasePlugin
+
+
+class GitPlugin(BasePlugin):
+    """Plugin for 'git' command - handles Git repository operations."""
+
+    name = "git"
+    help = "Manage Git repositories"
+
+    @classmethod
+    def get_arguments(cls, func):
+        func = click.argument("command", required=True)(func)
+        func = click.argument("repo_name", required=True)(func)
+        func = click.option(
+            "--target", "-t", help="Target directory name for clone operation"
+        )(func)
+        return func
+
+    @classmethod
+    def execute(cls, command, repo_name, target=None, **kwargs):
+        # Get the current path
+        current_path = os.getcwd()
+
+        # Check if the current path matches the expected pattern
+        pattern = r"^.*/workspace/github.com/([^/]+)$"
+        match = re.match(pattern, current_path)
+
+        if not match:
+            click.echo(
+                "Error: Current directory must be in ~/workspace/github.com/{username} format"
+            )
+            return
+
+        # Extract username from the path
+        username = match.group(1)
+
+        if command == "clone" or command == "cl":
+            # Determine the target directory name
+            target_dir = target if target else repo_name
+
+            # Construct the repository URL
+            repo_url = f"https://github.com/{username}/{repo_name}.git"
+
+            # Target path in the current directory
+            target_path = os.path.join(current_path, target_dir)
+
+            # Check if the target directory already exists
+            if os.path.exists(target_path):
+                click.echo(f"Error: Target directory '{target_dir}' already exists")
+                return
+
+            # Clone the repository
+            click.echo(f"Cloning {repo_url} into {target_path}...")
+            try:
+                result = subprocess.run(
+                    ["git", "clone", repo_url, target_path],
+                    capture_output=True,
+                    text=True,
+                )
+
+                if result.returncode == 0:
+                    click.echo(f"Successfully cloned {repo_name} to {target_path}")
+                else:
+                    click.echo(f"Error cloning repository: {result.stderr}")
+            except Exception as e:
+                click.echo(f"Error executing git command: {e}")
+
+        elif command == "rm":
+            # Path to the repository
+            repo_path = os.path.join(current_path, repo_name)
+
+            # Check if the repository exists
+            if not os.path.exists(repo_path):
+                click.echo(f"Error: Repository directory '{repo_name}' does not exist")
+                return
+
+            try:
+                # Remove the repository
+                subprocess.run(["rm", "-rf", repo_path], check=True)
+                click.echo(f"Successfully removed {repo_path}")
+            except Exception as e:
+                click.echo(f"Error removing repository: {e}")
+
+        else:
+            click.echo(f"Unknown command: {command}")
+            click.echo("Available commands: clone, rm")

toast/plugins/region_plugin.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+
+import click
+import subprocess
+from toast.plugins.base_plugin import BasePlugin
+from toast.plugins.utils import select_from_list
+
+class RegionPlugin(BasePlugin):
+    """Plugin for 'region' command - sets AWS region."""
+
+    name = "region"
+    help = "Set AWS region"
+
+    @classmethod
+    def execute(cls, **kwargs):
+        try:
+            result = subprocess.run(["aws", "ec2", "describe-regions", "--query", "Regions[].RegionName", "--output", "text"], capture_output=True, text=True)
+            regions = sorted(result.stdout.split())
+            if not regions:
+                click.echo("No regions found.")
+                return
+
+            selected_region = select_from_list(regions, "Select AWS Region")
+
+            if selected_region:
+                subprocess.run(["aws", "configure", "set", "default.region", selected_region])
+                subprocess.run(["aws", "configure", "set", "default.output", "json"])
+                click.echo(f"Set AWS region to {selected_region}")
+            else:
+                click.echo("No region selected.")
+        except Exception as e:
+            click.echo(f"Error fetching AWS regions: {e}")

toast/plugins/ssm_plugin.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+
+import click
+from toast.plugins.base_plugin import BasePlugin
+
+class SsmPlugin(BasePlugin):
+    """Plugin for 'ssm' command - runs SSM commands."""
+
+    name = "ssm"
+    help = "Run AWS SSM commands"
+
+    @classmethod
+    def execute(cls, **kwargs):
+        click.echo("Running SSM command")

toast/plugins/update_plugin.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+
+import click
+from toast.plugins.base_plugin import BasePlugin
+
+class UpdatePlugin(BasePlugin):
+    """Plugin for 'update' command - updates CLI tool."""
+
+    name = "update"
+    help = "Update CLI tool"
+
+    @classmethod
+    def execute(cls, **kwargs):
+        click.echo("Updating CLI tool")

toast/plugins/utils.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+
+import subprocess
+import click
+
+def select_from_list(options, prompt="Select an option"):
+    try:
+        fzf_proc = subprocess.run(["fzf", "--height=15", "--reverse", "--border", "--prompt", prompt+": "], input="\n".join(options), capture_output=True, text=True)
+        return fzf_proc.stdout.strip()
+    except Exception as e:
+        click.echo(f"Error selecting from list: {e}")
+        return None