workato-platform-cli 1.0.3__tar.gz → 1.0.5__tar.gz

workato_platform_cli-1.0.5/.github/workflows/claude-code-review.yml

@@ -0,0 +1,59 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize, ready_for_review, reopened]
+    # Optional: Only run on specific file changes
+    # paths:
+    #   - "src/**/*.py"
+
+jobs:
+  claude-review:
+    # Optional: Filter by PR author
+    # if: |
+    #   github.event.pull_request.user.login == 'external-contributor' ||
+    #   github.event.pull_request.user.login == 'new-developer' ||
+    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write  # Changed to write so Claude can comment
+      issues: read
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code Review
+        id: claude-review
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}  # Use workflow token to respect permissions
+          plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
+          plugins: 'code-review@claude-code-plugins'
+          claude_args: '--allowedTools WebSearch,WebFetch,Bash,Skill,Read,Glob'
+          prompt: |
+            /code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }} --comment
+
+            Before reviewing, research best practices for writing Python CLI tools:
+            - Search for official documentation on asyncclick, pydantic, and aiohttp
+            - Look for common patterns in popular open-source Python CLIs
+            - Understand proper use of async/await patterns
+            - Review examples of testing strategies for Python CLI tools
+            - Check for proper use of type annotations and mypy compliance
+
+            Also research Workato-specific knowledge:
+            - Research Workato platform concepts
+            - Review Workato Developer API documentation and patterns
+            - Understand Workato resource relationships and data models
+
+            Review instructions:
+            - Focus ONLY on critical issues and best practices violations
+            - Use bullet points, max 5 items total
+            - Be extremely concise - one sentence per issue
+            - Skip minor style/formatting issues
+            - Highlight any deviations from Python CLI development patterns

{workato_platform_cli-1.0.3 → workato_platform_cli-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workato-platform-cli
-Version: 1.0.3
+Version: 1.0.5
 Summary: CLI tool for the Workato Platform
 Project-URL: Homepage, https://github.com/workato-devs/workato-platform-cli
 Project-URL: Repository, https://github.com/workato-devs/workato-platform-cli.git

{workato_platform_cli-1.0.3 → workato_platform_cli-1.0.5}/src/workato_platform_cli/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.3'
-__version_tuple__ = version_tuple = (1, 0, 3)
+__version__ = version = '1.0.5'
+__version_tuple__ = version_tuple = (1, 0, 5)
 
 __commit_id__ = commit_id = None

{workato_platform_cli-1.0.3 → workato_platform_cli-1.0.5}/src/workato_platform_cli/cli/commands/connections.py

@@ -260,6 +260,7 @@ async def create(
 @connections.command(name="create-oauth")
 @click.option(
     "--parent-id",
+    type=int,
     required=True,
     help="ID of the parent OAuth connection (must be established/authorized)",
 )
@@ -269,7 +270,11 @@ async def create(
     type=int,
     help="ID of the project/folder (uses current project if not specified)",
 )
-@click.option("--external-id", help="End user string ID for identifying the connection")
+@click.option(
+    "--external-id",
+    required=True,
+    help="End user string ID for identifying the connection",
+)
 @click.option(
     "--callback-url",
     help="URL called back after successful token acquisition (optional)",

{workato_platform_cli-1.0.3 → workato_platform_cli-1.0.5}/src/workato_platform_cli/cli/commands/connectors/command.py

@@ -61,6 +61,10 @@ async def list_connectors(
 @click.option("--provider", help="Show parameters for a specific provider")
 @click.option("--oauth-only", is_flag=True, help="Show only OAuth-enabled providers")
 @click.option("--search", help="Search provider names (case-insensitive)")
+@click.option("--all", "show_all", is_flag=True, help="Output full schema as JSON")
+@click.option(
+    "--pretty", is_flag=True, help="Pretty-print JSON output (use with --all)"
+)
 @handle_cli_exceptions
 @inject
 @handle_api_exceptions
@@ -68,16 +72,33 @@ async def parameters(
     provider: str,
     oauth_only: bool,
     search: str,
+    show_all: bool,
+    pretty: bool,
     connector_manager: ConnectorManager = Provide[Container.connector_manager],
 ) -> None:
     """List connection parameters for connectors
 
     Shows configuration requirements for creating connections to different services.
     """
+    import json
 
     # Load the bundled connection data using the injected manager
     connection_data = connector_manager.load_connection_data()
 
+    # Handle --all flag - output raw schema data as JSON
+    if show_all:
+        # Convert ProviderData objects back to dict for JSON serialization
+        json_data = {}
+        for key, provider_data in connection_data.items():
+            json_data[key] = provider_data.model_dump()
+
+        # Pretty-print if --pretty flag is set
+        if pretty:
+            click.echo(json.dumps(json_data, indent=2))
+        else:
+            click.echo(json.dumps(json_data))
+        return
+
     if not connection_data:
         click.echo("❌ Connection parameter data not found.")
         click.echo()
@@ -172,6 +193,8 @@ async def parameters(
             "  • View provider details: workato connectors parameters "
             "--provider salesforce"
         )
+        click.echo("  • Get JSON schema: workato connectors parameters --all")
+        click.echo("  • Get pretty JSON: workato connectors parameters --all --pretty")
         click.echo(
             "  • Create connection: workato connections create --provider <PROVIDER> "
             "--name 'My Connection'"

{workato_platform_cli-1.0.3 → workato_platform_cli-1.0.5}/src/workato_platform_cli/cli/commands/init.py

@@ -43,6 +43,10 @@ from workato_platform_cli.client.workato_api.configuration import Configuration
     default="table",
     help="Output format: table (default) or json (only with --non-interactive)",
 )
+@click.option(
+    "--folder-name",
+    help="Custom folder name for the project (defaults to project name)",
+)
 @handle_cli_exceptions
 @handle_api_exceptions
 async def init(
@@ -54,6 +58,7 @@ async def init(
     project_id: int | None = None,
     non_interactive: bool = False,
     output_mode: str = "table",
+    folder_name: str | None = None,
 ) -> None:
     """Initialize Workato CLI for a new project
 
@@ -156,6 +161,7 @@ async def init(
         project_id=project_id,
         output_mode=output_mode,
         non_interactive=non_interactive,
+        folder_name=folder_name,
     )
 
     # Check if project directory exists and is non-empty

{workato_platform_cli-1.0.3 → workato_platform_cli-1.0.5}/src/workato_platform_cli/cli/commands/profiles.py

@@ -3,15 +3,24 @@
 import json
 import os
 
+from pathlib import Path
 from typing import Any
 
 import asyncclick as click
+import certifi
 
 from dependency_injector.wiring import Provide, inject
 
+from workato_platform_cli import Workato
 from workato_platform_cli.cli.containers import Container
 from workato_platform_cli.cli.utils.config import ConfigData, ConfigManager
+from workato_platform_cli.cli.utils.config.models import (
+    AVAILABLE_REGIONS,
+    ProfileData,
+    RegionInfo,
+)
 from workato_platform_cli.cli.utils.exception_handler import handle_cli_exceptions
+from workato_platform_cli.client.workato_api.configuration import Configuration
 
 
 @click.group()
@@ -337,6 +346,164 @@ async def status(
             click.echo("   💡 Or set WORKATO_API_TOKEN environment variable")
 
 
+def _format_file_path(file_path: Path) -> str:
+    """Format file path for display, showing relative to current directory."""
+    try:
+        rel_path = file_path.relative_to(Path.cwd())
+        return f"./{rel_path}"
+    except ValueError:
+        # File is outside current directory (shouldn't happen with cwd search)
+        return str(file_path)
+
+
+def _update_workatoenv_files(old_name: str, new_name: str) -> list[Path]:
+    """Find and update all .workatoenv files that reference the old profile name.
+
+    Searches recursively from current directory.
+    Returns list of updated file paths.
+    """
+    updated_files = []
+    current_dir = Path.cwd()
+
+    # Search from current directory for .workatoenv files
+    for workatoenv_file in current_dir.rglob(".workatoenv"):
+        try:
+            # Open for reading and writing
+            with open(workatoenv_file, "r+") as f:
+                data = json.load(f)
+
+                # Check if profile field matches old name
+                if data.get("profile") == old_name:
+                    # Update to new name
+                    data["profile"] = new_name
+
+                    # Write back (truncate and write from beginning)
+                    f.seek(0)
+                    f.truncate()
+                    json.dump(data, f, indent=2)
+                    f.write("\n")  # Add trailing newline
+
+                    updated_files.append(workatoenv_file)
+        except (OSError, json.JSONDecodeError):
+            # Skip files we can't read or parse
+            continue
+
+    return updated_files
+
+
+@profiles.command()
+@click.argument("old_name")
+@click.argument("new_name")
+@click.option(
+    "--output-mode",
+    type=click.Choice(["table", "json"]),
+    default="table",
+    help="Output format: table (default) or json",
+)
+@click.option(
+    "--yes",
+    is_flag=True,
+    help="Skip confirmation prompt",
+)
+@handle_cli_exceptions
+@inject
+async def rename(
+    old_name: str,
+    new_name: str,
+    output_mode: str = "table",
+    yes: bool = False,
+    config_manager: ConfigManager = Provide[Container.config_manager],
+) -> None:
+    """Rename a profile"""
+    # Check if old profile exists
+    old_profile = config_manager.profile_manager.get_profile(old_name)
+    if not old_profile:
+        if output_mode == "json":
+            error_msg = f"Profile '{old_name}' not found"
+            output_data: dict[str, Any] = {"status": "error", "error": error_msg}
+            click.echo(json.dumps(output_data))
+        else:
+            click.echo(f"❌ Profile '{old_name}' not found")
+            click.echo("💡 Use 'workato profiles list' to see available profiles")
+        return
+
+    # Check if new name already exists
+    if config_manager.profile_manager.get_profile(new_name):
+        if output_mode == "json":
+            error_msg = f"Profile '{new_name}' already exists"
+            output_data = {"status": "error", "error": error_msg}
+            click.echo(json.dumps(output_data))
+        else:
+            click.echo(f"❌ Profile '{new_name}' already exists")
+            click.echo(
+                "💡 Choose a different name or delete the existing profile first"
+            )
+        return
+
+    # Show confirmation prompt (skip in JSON mode or if --yes flag)
+    if (
+        not yes
+        and output_mode != "json"
+        and not click.confirm(f"Rename profile '{old_name}' to '{new_name}'?")
+    ):
+        click.echo("❌ Rename cancelled")
+        return
+
+    # Get the token from keyring
+    old_token = config_manager.profile_manager._get_token_from_keyring(old_name)
+
+    # Create new profile with same data and token
+    try:
+        config_manager.profile_manager.set_profile(new_name, old_profile, old_token)
+    except ValueError as e:
+        if output_mode == "json":
+            output_data = {"status": "error", "error": str(e)}
+            click.echo(json.dumps(output_data))
+        else:
+            click.echo(f"❌ Failed to create new profile: {e}")
+        return
+
+    # If old profile was current, set new profile as current
+    current_profile = config_manager.profile_manager.get_current_profile_name()
+    was_current = current_profile == old_name
+    if was_current:
+        config_manager.profile_manager.set_current_profile(new_name)
+
+    # Delete old profile
+    config_manager.profile_manager.delete_profile(old_name)
+
+    # Update all .workatoenv files that reference the old profile
+    if output_mode == "table":
+        click.echo("🔄 Updating project configurations...")
+    updated_files = _update_workatoenv_files(old_name, new_name)
+
+    # JSON output mode
+    if output_mode == "json":
+        output_data = {
+            "status": "success",
+            "old_name": old_name,
+            "new_name": new_name,
+            "was_current_profile": was_current,
+            "updated_files": [str(f) for f in updated_files],
+            "updated_files_count": len(updated_files),
+        }
+        click.echo(json.dumps(output_data))
+        return
+
+    # Table output mode (default)
+    click.echo("✅ Profile renamed successfully")
+    if was_current:
+        click.echo(f"✅ Set '{new_name}' as the active profile")
+
+    # Display updated files
+    if not updated_files:
+        return
+
+    click.echo(f"✅ Updated {len(updated_files)} project configuration(s)")
+    for file_path in updated_files:
+        click.echo(f"   • {_format_file_path(file_path)}")
+
+
 @profiles.command()
 @click.argument("profile_name")
 @click.confirmation_option(prompt="Are you sure you want to delete this profile?")
@@ -360,12 +527,83 @@ async def delete(
         click.echo(f"❌ Failed to delete profile '{profile_name}'")
 
 
+async def _create_profile_non_interactive(
+    region: str | None,
+    api_token: str | None,
+    api_url: str | None,
+) -> tuple[ProfileData, str] | None:
+    """Create profile data non-interactively.
+
+    Returns (ProfileData, token) on success, or None on error (error already echoed).
+    """
+    # Validate required parameters
+    if not region:
+        click.echo("❌ --region is required in non-interactive mode")
+        return None
+    if not api_token:
+        click.echo("❌ --api-token is required in non-interactive mode")
+        return None
+    if region == "custom" and not api_url:
+        click.echo("❌ --api-url is required when region=custom")
+        return None
+
+    # Get region info
+    if region == "custom":
+        region_info = RegionInfo(region="custom", name="Custom", url=api_url)
+    else:
+        region_info_lookup = AVAILABLE_REGIONS.get(region)
+        if not region_info_lookup:
+            click.echo(f"❌ Invalid region: {region}")
+            return None
+        region_info = region_info_lookup
+
+    # Validate credentials and get workspace info
+    api_config = Configuration(
+        access_token=api_token, host=region_info.url, ssl_ca_cert=certifi.where()
+    )
+    try:
+        async with Workato(configuration=api_config) as workato_api_client:
+            user_info = await workato_api_client.users_api.get_workspace_details()
+    except Exception as e:
+        click.echo(f"❌ Authentication failed: {e}")
+        return None
+
+    profile_data = ProfileData(
+        region=region_info.region,
+        region_url=region_info.url,
+        workspace_id=user_info.id,
+    )
+    return profile_data, api_token
+
+
 @profiles.command()
 @click.argument("profile_name")
+@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(
+    "--non-interactive",
+    is_flag=True,
+    help="Run in non-interactive mode (requires --region and --api-token)",
+)
 @handle_cli_exceptions
 @inject
 async def create(
     profile_name: str,
+    region: str | None = None,
+    api_token: str | None = None,
+    api_url: str | None = None,
+    non_interactive: bool = False,
     config_manager: ConfigManager = Provide[Container.config_manager],
 ) -> None:
     """Create a new profile with API credentials"""
@@ -377,31 +615,38 @@ async def create(
         click.echo("💡 Or use 'workato profiles delete' to remove it first")
         return
 
-    click.echo(f"🔧 Creating profile: {profile_name}")
-    click.echo()
-
-    # Create profile interactively
-    try:
-        (
-            profile_data,
-            token,
-        ) = await config_manager.profile_manager.create_profile_interactive(
-            profile_name
-        )
-    except click.ClickException:
-        click.echo("❌ Profile creation cancelled")
-        return
+    # Get profile data and token (either interactively or non-interactively)
+    if non_interactive:
+        result = await _create_profile_non_interactive(region, api_token, api_url)
+        if result is None:
+            return
+        profile_data, token = result
+    else:
+        click.echo(f"🔧 Creating profile: {profile_name}")
+        click.echo()
 
-    # Save profile
+        try:
+            (
+                profile_data,
+                token,
+            ) = await config_manager.profile_manager.create_profile_interactive(
+                profile_name
+            )
+        except click.ClickException:
+            click.echo("❌ Profile creation cancelled")
+            return
+
+    # Save profile (common for both modes)
     try:
         config_manager.profile_manager.set_profile(profile_name, profile_data, token)
     except ValueError as e:
         click.echo(f"❌ Failed to save profile: {e}")
         return
 
-    # Set as current profile
+    # Set as current profile (common for both modes)
     config_manager.profile_manager.set_current_profile(profile_name)
 
+    # Success message (common for both modes)
     click.echo(f"✅ Profile '{profile_name}' created successfully")
     click.echo(f"✅ Set '{profile_name}' as the active profile")
     click.echo()

{workato_platform_cli-1.0.3 → workato_platform_cli-1.0.5}/src/workato_platform_cli/cli/utils/config/manager.py

@@ -56,6 +56,7 @@ class ConfigManager:
         project_id: int | None = None,
         output_mode: str = "table",
         non_interactive: bool = False,
+        folder_name: str | None = None,
     ) -> "ConfigManager":
         """Initialize workspace with interactive or non-interactive setup"""
         if output_mode == "table":
@@ -80,14 +81,15 @@ class ConfigManager:
                 api_url=api_url,
                 project_name=project_name,
                 project_id=project_id,
+                folder_name=folder_name,
             )
         else:
             # Run setup flow
-            await manager._run_setup_flow()
+            await manager._run_setup_flow(folder_name=folder_name)
 
         return manager
 
-    async def _run_setup_flow(self) -> None:
+    async def _run_setup_flow(self, folder_name: str | None = None) -> None:
         """Run the complete setup flow"""
         workspace_root = self.workspace_manager.find_workspace_root()
         self.config_dir = workspace_root
@@ -99,7 +101,7 @@ class ConfigManager:
         profile_name = await self._setup_profile()
 
         # Step 2: Project setup
-        await self._setup_project(profile_name, workspace_root)
+        await self._setup_project(profile_name, workspace_root, folder_name)
 
         # Step 3: Create workspace files
         self._create_workspace_files(workspace_root)
@@ -114,6 +116,7 @@ class ConfigManager:
         api_url: str | None = None,
         project_name: str | None = None,
         project_id: int | None = None,
+        folder_name: str | None = None,
     ) -> None:
         """Perform all setup actions non-interactively"""
 
@@ -238,7 +241,9 @@ class ConfigManager:
 
             # Project doesn't exist locally - create new directory
             current_dir = Path.cwd().resolve()
-            project_path = current_dir / selected_project.name
+            # Use custom folder name if provided, otherwise use project name
+            folder_name = folder_name if folder_name else selected_project.name
+            project_path = current_dir / folder_name
 
             # Create project directory
             project_path.mkdir(parents=True, exist_ok=True)
@@ -552,7 +557,9 @@ class ConfigManager:
         # Save profile and token
         self.profile_manager.set_profile(profile_name, profile_data, token)
 
-    async def _setup_project(self, profile_name: str, workspace_root: Path) -> None:
+    async def _setup_project(
+        self, profile_name: str, workspace_root: Path, folder_name: str | None = None
+    ) -> None:
         """Setup project interactively"""
         click.echo("📁 Step 2: Setup project")
 
@@ -607,6 +614,16 @@ class ConfigManager:
             if not selected_project:
                 raise click.ClickException("No project selected")
 
+            # Prompt for custom folder name if not provided via CLI
+            if folder_name is None:
+                click.echo()
+                custom_name = await click.prompt(
+                    "Folder name (leave blank for default)",
+                    default=selected_project.name,
+                    type=str,
+                )
+                folder_name = custom_name.strip() if custom_name.strip() else None
+
             # Check if this specific project already exists locally in the workspace
             local_projects = self._find_all_projects(workspace_root)
             existing_local_path = None
@@ -641,7 +658,9 @@ class ConfigManager:
             else:
                 # Project doesn't exist locally - create new directory
                 current_dir = Path.cwd().resolve()
-                project_path = current_dir / selected_project.name
+                # Use custom folder name if provided, otherwise use project name
+                folder_name = folder_name if folder_name else selected_project.name
+                project_path = current_dir / folder_name
 
             # Validate project path
             try:

{workato_platform_cli-1.0.3 → workato_platform_cli-1.0.5}/src/workato_platform_cli/cli/utils/config/profiles.py

@@ -296,8 +296,8 @@ class ProfileManager:
         # Set secure permissions (only user can read/write)
         temp_file.chmod(0o600)
 
-        # Atomic rename
-        temp_file.rename(self.profiles_file)
+        # Atomic replace (works cross-platform, including Windows)
+        temp_file.replace(self.profiles_file)
 
     def get_profile(self, profile_name: str) -> ProfileData | None:
         """Get profile data by name"""