workato-platform-cli 1.0.0rc5.dev5__py3-none-any.whl

workato_platform_cli/cli/commands/init.py

@@ -0,0 +1,229 @@
+"""Initialize Workato CLI for a new project"""
+
+import json
+
+from typing import Any
+
+import asyncclick as click
+import certifi
+
+from workato_platform_cli import Workato
+from workato_platform_cli.cli.commands.projects.project_manager import ProjectManager
+from workato_platform_cli.cli.commands.pull import _pull_project
+from workato_platform_cli.cli.utils.config import ConfigManager
+from workato_platform_cli.cli.utils.exception_handler import (
+    handle_api_exceptions,
+    handle_cli_exceptions,
+)
+from workato_platform_cli.client.workato_api.configuration import Configuration
+
+
+@click.command()
+@click.option("--profile", help="Profile name to use (creates new if doesn't exist)")
+@click.option(
+    "--region",
+    type=click.Choice(["us", "eu", "jp", "au", "sg", "custom"]),
+    help="Workato region",
+)
+@click.option("--api-token", help="Workato API token")
+@click.option("--api-url", help="Custom API URL (required when region=custom)")
+@click.option(
+    "--project-name", help="Project name (creates new project with this name)"
+)
+@click.option("--project-id", type=int, help="Existing project ID to use")
+@click.option(
+    "--non-interactive",
+    is_flag=True,
+    help="Run in non-interactive mode (requires all necessary options)",
+)
+@click.option(
+    "--output-mode",
+    type=click.Choice(["table", "json"]),
+    default="table",
+    help="Output format: table (default) or json (only with --non-interactive)",
+)
+@handle_cli_exceptions
+@handle_api_exceptions
+async def init(
+    profile: str | None = None,
+    region: str | None = None,
+    api_token: str | None = None,
+    api_url: str | None = None,
+    project_name: str | None = None,
+    project_id: int | None = None,
+    non_interactive: bool = False,
+    output_mode: str = "table",
+) -> None:
+    """Initialize Workato CLI for a new project"""
+
+    # Validate that --output-mode json requires --non-interactive
+    if output_mode == "json" and not non_interactive:
+        # Return JSON error for consistency
+        error_data: dict[str, Any] = {
+            "status": "error",
+            "error": "--output-mode json can only be used with --non-interactive flag",
+            "error_code": "INVALID_OPTIONS",
+        }
+        click.echo(json.dumps(error_data))
+        return
+
+    if non_interactive:
+        # Validate required parameters for non-interactive mode
+        error_msg = None
+        error_code = None
+
+        # Either profile OR individual attributes (region, api_token) are required
+        if not profile and not (region and api_token):
+            error_msg = (
+                "Either --profile or both --region and --api-token are required "
+                "in non-interactive mode"
+            )
+            error_code = "MISSING_REQUIRED_OPTIONS"
+        elif region == "custom" and not api_url:
+            error_msg = (
+                "--api-url is required when region=custom in non-interactive mode"
+            )
+            error_code = "MISSING_REQUIRED_OPTIONS"
+        elif not project_name and not project_id:
+            error_msg = (
+                "Either --project-name or --project-id is required in "
+                "non-interactive mode"
+            )
+            error_code = "MISSING_REQUIRED_OPTIONS"
+        elif project_name and project_id:
+            error_msg = "Cannot specify both --project-name and --project-id"
+            error_code = "CONFLICTING_OPTIONS"
+
+        if error_msg:
+            if output_mode == "json":
+                error_data = {
+                    "status": "error",
+                    "error": error_msg,
+                    "error_code": error_code,
+                }
+                click.echo(json.dumps(error_data))
+                return
+            else:
+                click.echo(f"❌ {error_msg}")
+                raise click.Abort()  # For non-JSON mode, keep the normal abort behavior
+
+    # Initialize JSON output data structure if in JSON mode
+    # Since we've already validated that json mode requires non-interactive,
+    # we can use output_data existence as our flag throughout the code
+    output_data = None
+    if output_mode == "json":
+        output_data = {
+            "status": "success",
+            "profile": {},
+            "project": {},
+        }
+
+    config_manager = await ConfigManager.initialize(
+        profile_name=profile,
+        region=region,
+        api_token=api_token,
+        api_url=api_url,
+        project_name=project_name,
+        project_id=project_id,
+        output_mode=output_mode,
+        non_interactive=non_interactive,
+    )
+
+    # Check if project directory exists and is non-empty
+    # Exclude CLI-managed files from the check
+    cli_managed_files = {".workatoenv", ".gitignore", ".workato-ignore"}
+    project_dir = config_manager.get_project_directory()
+    has_user_files = False
+    if project_dir and project_dir.exists():
+        # Check for files that are not CLI-managed
+        has_user_files = any(
+            item.name not in cli_managed_files for item in project_dir.iterdir()
+        )
+
+    if has_user_files:
+        # Directory is non-empty
+        if non_interactive:
+            # In non-interactive mode, fail with error
+            error_msg = (
+                f"Directory '{project_dir}' is not empty. "
+                "Please use an empty directory or remove existing files."
+            )
+            if output_mode == "json":
+                error_data = {
+                    "status": "error",
+                    "error": error_msg,
+                    "error_code": "DIRECTORY_NOT_EMPTY",
+                }
+                click.echo(json.dumps(error_data))
+                return
+            else:
+                click.echo(f"❌ {error_msg}")
+                raise click.Abort()
+        else:
+            # Interactive mode - ask for confirmation
+            click.echo(f"⚠️  Directory '{project_dir}' is not empty.")
+            if not click.confirm(
+                "Proceed with initialization? This may overwrite or delete files.",
+                default=False,
+            ):
+                click.echo("❌ Initialization cancelled")
+                return
+
+    # Automatically run pull to set up project structure
+    if not output_data:
+        click.echo()
+
+    # Get API credentials from the newly configured profile
+    config_data = config_manager.load_config()
+    project_profile_override = config_data.profile
+    api_token, api_host = config_manager.profile_manager.resolve_environment_variables(
+        project_profile_override
+    )
+
+    # Populate profile data for JSON output
+    if output_data:
+        profile_data = config_manager.profile_manager.get_profile(
+            project_profile_override
+            or config_manager.profile_manager.get_current_profile_name()
+            or "",
+        )
+        if profile_data:
+            output_data["profile"] = {
+                "name": project_profile_override
+                or config_manager.profile_manager.get_current_profile_name(),
+                "region": profile_data.region,
+                "region_name": profile_data.region_name,
+                "api_url": profile_data.region_url,
+                "workspace_id": profile_data.workspace_id,
+            }
+
+    # Create API client configuration
+    api_config = Configuration(
+        access_token=api_token, host=api_host, ssl_ca_cert=certifi.where()
+    )
+
+    # Create project manager and run pull
+    async with Workato(configuration=api_config) as workato_api_client:
+        project_manager = ProjectManager(workato_api_client=workato_api_client)
+        await _pull_project(
+            config_manager=config_manager,
+            project_manager=project_manager,
+            non_interactive=non_interactive,
+        )
+
+        # Populate project data for JSON output
+        if output_data:
+            meta_data = config_manager.load_config()
+            project_path = config_manager.get_project_directory()
+            output_data["project"] = {
+                "name": meta_data.project_name or "project",
+                "id": meta_data.project_id,
+                "folder_id": meta_data.folder_id,
+                "path": str(project_path) if project_path else None,
+            }
+
+    # Output final result
+    if output_data:
+        click.echo(json.dumps(output_data))
+    else:
+        click.echo("🎉 Project setup complete!")

workato_platform_cli/cli/commands/profiles.py

@@ -0,0 +1,364 @@
+"""Manage Workato profiles for multi-environment configurations"""
+
+import json
+import os
+
+from typing import Any
+
+import asyncclick as click
+
+from dependency_injector.wiring import Provide, inject
+
+from workato_platform_cli.cli.containers import Container
+from workato_platform_cli.cli.utils.config import ConfigData, ConfigManager
+from workato_platform_cli.cli.utils.exception_handler import handle_cli_exceptions
+
+
+@click.group()
+def profiles() -> None:
+    """Manage Workato profiles for multi-environment configurations"""
+    pass
+
+
+@profiles.command(name="list")
+@click.option(
+    "--output-mode",
+    type=click.Choice(["table", "json"]),
+    default="table",
+    help="Output format: table (default) or json",
+)
+@handle_cli_exceptions
+@inject
+async def list_profiles(
+    output_mode: str = "table",
+    config_manager: ConfigManager = Provide[Container.config_manager],
+) -> None:
+    """List all available profiles"""
+    profiles_dict = config_manager.profile_manager.list_profiles()
+    current_profile_name = config_manager.profile_manager.get_current_profile_name()
+
+    if output_mode == "json":
+        # JSON output mode - return structured data
+        output_data: dict[str, Any] = {
+            "current_profile": current_profile_name,
+            "profiles": {},
+        }
+
+        for name, profile_data in profiles_dict.items():
+            output_data["profiles"][name] = profile_data.model_dump()
+            output_data["profiles"][name]["is_current"] = name == current_profile_name
+
+        click.echo(json.dumps(output_data))
+        return
+
+    # Table output mode (default)
+    if not profiles_dict:
+        click.echo("📋 No profiles configured")
+        click.echo("💡 Run 'workato init' to create your first profile")
+        return
+
+    click.echo("📋 Available profiles:")
+    for name, profile_data in profiles_dict.items():
+        current_indicator = " (current)" if name == current_profile_name else ""
+        click.echo(f"  • {name}{current_indicator}")
+        click.echo(f"    Region: {profile_data.region_name} ({profile_data.region})")
+        click.echo(f"    URL: {profile_data.region_url}")
+        click.echo(f"    Workspace ID: {profile_data.workspace_id}")
+        click.echo()
+
+
+@profiles.command()
+@handle_cli_exceptions
+@inject
+async def show(
+    profile_name: str,
+    config_manager: ConfigManager = Provide[Container.config_manager],
+) -> None:
+    """Show details of a specific profile"""
+    profile_data = config_manager.profile_manager.get_profile(profile_name)
+
+    if not profile_data:
+        click.echo(f"❌ Profile '{profile_name}' not found")
+        return
+
+    current_profile_name = config_manager.profile_manager.get_current_profile_name()
+    is_current = profile_name == current_profile_name
+
+    click.echo(f"📋 Profile: {profile_name}")
+    if is_current:
+        click.echo("✅ This is the current active profile")
+    click.echo()
+    click.echo("🌍 Region Information:")
+    click.echo(f"   Code: {profile_data.region}")
+    click.echo(f"   Name: {profile_data.region_name}")
+    click.echo(f"   URL: {profile_data.region_url}")
+    click.echo()
+    click.echo("🏢 Workspace:")
+    click.echo(f"   ID: {profile_data.workspace_id}")
+    click.echo()
+    click.echo("🔑 Authentication:")
+
+    # Check if token is available using profile manager resolution
+    api_token, _ = config_manager.profile_manager.resolve_environment_variables(
+        profile_name
+        if profile_name != config_manager.profile_manager.get_current_profile_name()
+        else None
+    )
+
+    if api_token:
+        click.echo("   Status: ✅ Token configured")
+        # Show where the token is coming from
+        if os.environ.get("WORKATO_API_TOKEN"):
+            click.echo("   Source: WORKATO_API_TOKEN environment variable")
+        else:
+            click.echo("   Source: ~/.workato/profiles")
+    else:
+        click.echo("   Status: ❌ Token not found")
+        click.echo("   💡 Token should be stored in keyring")
+        click.echo("   💡 Or set WORKATO_API_TOKEN environment variable")
+
+
+@profiles.command()
+@click.argument("profile_name")
+@handle_cli_exceptions
+@inject
+async def use(
+    profile_name: str,
+    config_manager: ConfigManager = Provide[Container.config_manager],
+) -> None:
+    """Set the current active profile (context-aware: workspace or global)"""
+    profile_data = config_manager.profile_manager.get_profile(profile_name)
+
+    if not profile_data:
+        click.echo(f"❌ Profile '{profile_name}' not found")
+        click.echo("💡 Use 'workato profiles list' to see available profiles")
+        return
+
+    # Check if we're in a workspace context
+    try:
+        workspace_root = config_manager.get_workspace_root()
+        config_data = config_manager.load_config()
+    except Exception:
+        workspace_root = None
+        config_data = ConfigData.model_construct()
+
+    # If we have a workspace config (project_id exists), update workspace profile
+    if config_data.project_id and workspace_root:
+        config_data.profile = profile_name
+        config_manager.save_config(config_data)
+        click.echo(f"✅ Set '{profile_name}' as profile for current workspace")
+        click.echo(f"   Workspace: {workspace_root}")
+
+        # Also update project config if it exists
+        project_dir = config_manager.get_project_directory()
+        if project_dir and project_dir != workspace_root:
+            project_config_manager = ConfigManager(project_dir, skip_validation=True)
+            project_config = project_config_manager.load_config()
+            if project_config.project_id:
+                project_config.profile = profile_name
+                project_config_manager.save_config(project_config)
+                project_dir = project_dir.relative_to(workspace_root)
+                click.echo(f"   Project config also updated: {project_dir}")
+    else:
+        # No workspace context, set global profile
+        config_manager.profile_manager.set_current_profile(profile_name)
+        click.echo(f"✅ Set '{profile_name}' as global default profile")
+
+
+@profiles.command()
+@click.option(
+    "--output-mode",
+    type=click.Choice(["table", "json"]),
+    default="table",
+    help="Output format: table (default) or json",
+)
+@handle_cli_exceptions
+@inject
+async def status(
+    output_mode: str = "table",
+    config_manager: ConfigManager = Provide[Container.config_manager],
+) -> None:
+    """Show current profile status and configuration"""
+    # Get project config to check for profile override
+    config_data = config_manager.load_config()
+    project_profile_override = config_data.profile
+
+    # Get effective profile name
+    current_profile_name = config_manager.profile_manager.get_current_profile_name(
+        project_profile_override
+    )
+
+    output_data: dict[str, Any] = {}
+
+    if not current_profile_name:
+        if output_mode == "json":
+            output_data = {"profile": None, "error": "No active profile configured"}
+            click.echo(json.dumps(output_data, indent=2))
+        else:
+            click.echo("❌ No active profile configured")
+            click.echo("💡 Run 'workato init' to create and set a profile")
+        return
+
+    # JSON output mode
+    if output_mode == "json":
+        # Profile information
+        profile_source_type = None
+        profile_source_location = None
+        if project_profile_override:
+            profile_source_type = "project_override"
+            profile_source_location = ".workatoenv"
+        elif os.environ.get("WORKATO_PROFILE"):
+            profile_source_type = "environment_variable"
+            profile_source_location = "WORKATO_PROFILE"
+        else:
+            profile_source_type = "global_default"
+            profile_source_location = "~/.workato/profiles"
+
+        profile_data = config_manager.profile_manager.get_current_profile_data(
+            project_profile_override
+        )
+
+        output_data["profile"] = {
+            "name": current_profile_name,
+            "source": {
+                "type": profile_source_type,
+                "location": profile_source_location,
+            },
+        }
+
+        if profile_data:
+            output_data["profile"]["configuration"] = {
+                "region": {
+                    "code": profile_data.region,
+                    "name": profile_data.region_name,
+                    "url": profile_data.region_url,
+                },
+                "workspace_id": profile_data.workspace_id,
+            }
+
+        # Authentication information
+        api_token, _ = config_manager.profile_manager.resolve_environment_variables(
+            project_profile_override
+        )
+
+        if api_token:
+            auth_source_type = None
+            auth_source_location = None
+            if os.environ.get("WORKATO_API_TOKEN"):
+                auth_source_type = "environment_variable"
+                auth_source_location = "WORKATO_API_TOKEN"
+            else:
+                auth_source_type = "keyring"
+                auth_source_location = "~/.workato/profiles"
+
+            output_data["authentication"] = {
+                "configured": True,
+                "source": {"type": auth_source_type, "location": auth_source_location},
+            }
+        else:
+            output_data["authentication"] = {"configured": False}
+
+        # Project information
+        try:
+            workspace_root = config_manager.get_workspace_root()
+            if workspace_root and (config_data.project_id or config_data.project_name):
+                project_metadata: dict[str, Any] = {}
+                if config_data.project_name:
+                    project_metadata["name"] = config_data.project_name
+                if config_data.project_id:
+                    project_metadata["id"] = config_data.project_id
+                if config_data.folder_id:
+                    project_metadata["folder_id"] = config_data.folder_id
+
+                project_path = config_manager.get_project_directory()
+
+                if project_path:
+                    output_data["project"] = {
+                        "configured": True,
+                        "path": str(project_path),
+                        "metadata": project_metadata,
+                    }
+                else:
+                    output_data["project"] = {"configured": False}
+            else:
+                output_data["project"] = {"configured": False}
+        except Exception:
+            output_data["project"] = {"configured": False}
+
+        click.echo(json.dumps(output_data))
+        return
+
+    # Table output (existing code)
+    click.echo("📊 Profile Status:")
+    click.echo(f"   Current Profile: {current_profile_name}")
+
+    # Show source of profile selection
+    if project_profile_override:
+        click.echo("   Source: Project override (from .workatoenv)")
+    else:
+        env_profile = os.environ.get("WORKATO_PROFILE")
+        if env_profile:
+            click.echo("   Source: Environment variable (WORKATO_PROFILE)")
+        else:
+            click.echo("   Source: Global setting (~/.workato/profiles)")
+
+    click.echo()
+
+    # Show profile details
+    profile_data = config_manager.profile_manager.get_current_profile_data(
+        project_profile_override
+    )
+
+    if profile_data:
+        click.echo("🌍 Active Profile Details:")
+        click.echo(f"   Region: {profile_data.region_name} ({profile_data.region})")
+        click.echo(f"   URL: {profile_data.region_url}")
+        click.echo(f"   Workspace ID: {profile_data.workspace_id}")
+        click.echo()
+
+        # Check authentication status
+        click.echo("🔑 Authentication:")
+
+        # Check if token is available using profile manager resolution
+        api_token, _ = config_manager.profile_manager.resolve_environment_variables(
+            project_profile_override
+        )
+
+        if api_token:
+            click.echo("   Status: ✅ Token configured")
+            # Show where the token is coming from
+            if os.environ.get("WORKATO_API_TOKEN"):
+                click.echo("   Source: WORKATO_API_TOKEN environment variable")
+            else:
+                click.echo("   Source: ~/.workato/profiles")
+        else:
+            click.echo("   Status: ❌ Token not found")
+            click.echo("   💡 Token should be stored in keyring")
+            click.echo("   💡 Or set WORKATO_API_TOKEN environment variable")
+
+
+@profiles.command()
+@click.argument("profile_name")
+@click.confirmation_option(prompt="Are you sure you want to delete this profile?")
+@handle_cli_exceptions
+@inject
+async def delete(
+    profile_name: str,
+    config_manager: ConfigManager = Provide[Container.config_manager],
+) -> None:
+    """Delete a profile"""
+    if not config_manager.profile_manager.get_profile(profile_name):
+        click.echo(f"❌ Profile '{profile_name}' not found")
+        return
+
+    success = config_manager.profile_manager.delete_profile(profile_name)
+
+    if success:
+        click.echo(f"✅ Profile '{profile_name}' deleted successfully")
+        click.echo("💡 Profile removed from ~/.workato/profiles")
+    else:
+        click.echo(f"❌ Failed to delete profile '{profile_name}'")
+
+
+# Add show as click argument command
+show = click.argument("profile_name")(show)