onehouse-cli 0.1.0__py3-none-any.whl

onehouse_cli/__init__.py

@@ -0,0 +1,10 @@
+"""
+Onehouse CLI - A command-line tool for executing SQL commands against the Onehouse API.
+"""
+
+__version__ = "0.1.0"
+
+from .cli import main as cli_main
+from .configure import main as configure_main
+
+__all__ = ["cli_main", "configure_main"]

onehouse_cli/cli.py

@@ -0,0 +1,390 @@
+"""
+Onehouse CLI Tool
+Execute SQL commands against Onehouse API using stored credentials.
+"""
+
+import os
+import json
+import sys
+import argparse
+import requests
+import time
+from pathlib import Path
+
+
+def load_credentials():
+    """Load credentials from ~/.onehouse/credentials file."""
+    credentials_file = Path.home() / ".onehouse" / "credentials"
+    if not credentials_file.exists():
+        print("Error: No credentials found. Run 'onehouse-cli-configure' first to set up credentials.")
+        return None
+
+    try:
+        with open(credentials_file, 'r') as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError) as e:
+        print(f"Error reading credentials file: {e}")
+        return None
+
+
+def get_profile_credentials(credentials, profile_name):
+    """Get credentials for a specific profile."""
+    if profile_name not in credentials:
+        available_profiles = list(credentials.keys())
+        print(f"Error: Profile '{profile_name}' not found.")
+        if available_profiles:
+            print(f"Available profiles: {', '.join(available_profiles)}")
+        else:
+            print("No profiles found. Run 'onehouse-cli-configure' to create one.")
+        return None
+
+    return credentials[profile_name]
+
+
+def check_request_status(profile_creds, request_id):
+    """Check the status of a request using the status endpoint."""
+    api_endpoint = profile_creds.get('api_endpoint', 'https://api.onehouse.ai')
+    url = f"{api_endpoint}/v1/status/{request_id}"
+
+    headers = {
+        'x-onehouse-account-uid': profile_creds['account_uid'],
+        'x-onehouse-project-uid': profile_creds['project_uid'],
+        'x-onehouse-api-key': profile_creds['api_key'],
+        'x-onehouse-api-secret': profile_creds['api_secret'],
+        'x-onehouse-region': profile_creds['project_region'],
+        'x-onehouse-uuid': profile_creds['user_id']
+    }
+
+    try:
+        response = requests.get(url, headers=headers)
+
+        if response.status_code == 200:
+            result = response.json()
+            return result
+        else:
+            print(f"Status check failed with status {response.status_code}")
+            try:
+                error_data = response.json()
+                print("Error response:", json.dumps(error_data, indent=2))
+            except json.JSONDecodeError:
+                print("Error response:", response.text)
+            return None
+
+    except requests.exceptions.RequestException as e:
+        print(f"Status check request failed: {e}")
+        return None
+
+
+def check_status_async(profile_creds, request_id):
+    """Check the status of a request asynchronously without timeout."""
+    print(f"Checking status for request ID: {request_id}")
+
+    status_result = check_request_status(profile_creds, request_id)
+
+    if status_result is None:
+        print("Failed to check status.")
+        return False
+
+    # Try different possible status field names
+    status = (status_result.get('status') or
+             status_result.get('state') or
+             status_result.get('jobStatus') or
+             status_result.get('requestStatus') or
+             status_result.get('apiStatus') or '').lower()
+
+    print(f"Current Status: {status}")
+
+    if status in ['completed', 'success', 'finished', 'done', 'succeed', 'api_operation_status_success']:
+        print("✅ Request completed successfully!")
+
+        # Only show result if it's not empty
+        result_to_show = status_result.get('apiResponse', status_result)
+        if result_to_show and result_to_show != {}:
+            print("Result:")
+            print(json.dumps(result_to_show, indent=2))
+        return True
+    elif status in ['failed', 'error', 'failure', 'api_operation_status_failed', 'api_operation_status_error']:
+        print("❌ Request failed!")
+        print("Error details:")
+        print(json.dumps(status_result, indent=2))
+        return False
+    elif status in ['running', 'processing', 'in_progress', 'pending', 'submitted', 'queued', 'api_operation_status_pending']:
+        print("⏳ Request is still in progress...")
+        print("Full status details:")
+        print(json.dumps(status_result, indent=2))
+        return True
+    else:
+        print(f"⚠️ Request has status: {status}")
+        print("Full status details:")
+        print(json.dumps(status_result, indent=2))
+        return True
+
+
+def wait_for_completion(profile_creds, request_id, timeout_minutes=10):
+    """Poll the status endpoint until completion or timeout."""
+    timeout_seconds = timeout_minutes * 60
+    start_time = time.time()
+    last_status = None
+    progress_shown = False
+
+    while time.time() - start_time < timeout_seconds:
+        status_result = check_request_status(profile_creds, request_id)
+
+        if status_result is None:
+            print("Failed to check status, retrying in 1 second...")
+            time.sleep(1)
+            continue
+
+        # Try different possible status field names
+        status = (status_result.get('status') or
+                 status_result.get('state') or
+                 status_result.get('jobStatus') or
+                 status_result.get('requestStatus') or
+                 status_result.get('apiStatus') or '').lower()
+
+        # Only print status if it changed or it's the first time
+        if status != last_status:
+            print(f"Status: {status}")
+            last_status = status
+
+        if status in ['completed', 'success', 'finished', 'done', 'succeed', 'api_operation_status_success']:
+            print("✅ Command completed successfully!")
+
+            # Only show result if it's not empty
+            result_to_show = status_result.get('apiResponse', status_result)
+            if result_to_show and result_to_show != {}:
+                print("Final Result:")
+                print(json.dumps(result_to_show, indent=2))
+            return True
+        elif status in ['failed', 'error', 'failure', 'api_operation_status_failed', 'api_operation_status_error']:
+            print("❌ Command failed!")
+            print("Error details:")
+            print(json.dumps(status_result, indent=2))
+            return False
+        elif status in ['running', 'processing', 'in_progress', 'pending', 'submitted', 'queued', 'api_operation_status_pending']:
+            if not progress_shown:
+                print("⏳ Request is in progress...")
+                progress_shown = True
+            time.sleep(1)
+        else:
+            if not progress_shown:
+                print(f"⏳ Request status is '{status}', monitoring progress...")
+                progress_shown = True
+            time.sleep(1)
+
+    print(f"⏰ Timeout reached after {timeout_minutes} minutes")
+    print(f"You can check the status later using: onehouse-cli --check-status {request_id} --profile {profile_creds.get('name', 'your-profile')}")
+    return False
+
+
+def execute_command(profile_creds, command, timeout_minutes=10):
+    """Execute a command against the Onehouse API and wait for completion."""
+    api_endpoint = profile_creds.get('api_endpoint', 'https://api.onehouse.ai')
+    url = f"{api_endpoint}/v1/resource/"
+
+    headers = {
+        'x-onehouse-account-uid': profile_creds['account_uid'],
+        'x-onehouse-project-uid': profile_creds['project_uid'],
+        'x-onehouse-api-key': profile_creds['api_key'],
+        'x-onehouse-api-secret': profile_creds['api_secret'],
+        'Content-Type': 'application/json',
+        'x-onehouse-region': profile_creds['project_region'],
+        'x-onehouse-uuid': profile_creds['user_id']
+    }
+
+    # Add required request_id header
+    headers['x-onehouse-link-uid'] = profile_creds['request_id']
+
+    payload = {
+        "statement": command
+    }
+
+    try:
+        print(f"Executing command: {command}")
+        print("Making API request...")
+
+        response = requests.post(url, headers=headers, json=payload)
+
+        print(f"Response Status: {response.status_code}")
+
+        if response.status_code == 200:
+            try:
+                result = response.json()
+                print("Initial Response:")
+                print(json.dumps(result, indent=2))
+
+                # Extract request ID from response if available
+                async_request_id = result.get('requestId') or result.get('request_id') or result.get('id')
+
+                if async_request_id:
+                    print(f"Request ID: {async_request_id}")
+                    return wait_for_completion(profile_creds, async_request_id, timeout_minutes)
+                else:
+                    print("No request ID found in response - command may have completed immediately")
+                    return True
+
+            except json.JSONDecodeError:
+                print("Response (raw text):")
+                print(response.text)
+                return True
+        else:
+            print("Error Response:")
+            print(f"Status Code: {response.status_code}")
+            print("Headers:")
+            for header, value in response.headers.items():
+                print(f"  {header}: {value}")
+            print("Body:")
+            try:
+                error_data = response.json()
+                print(json.dumps(error_data, indent=2))
+            except json.JSONDecodeError:
+                print(response.text if response.text else "(empty)")
+            return False
+
+    except requests.exceptions.RequestException as e:
+        print(f"Request failed: {e}")
+        return False
+
+
+def list_profiles(credentials):
+    """List all available profiles."""
+    if not credentials:
+        print("No profiles found.")
+        return
+
+    default_profile = credentials.get('_default', None)
+
+    print("Available profiles:")
+    for profile_name, profile_data in credentials.items():
+        # Skip the _default entry
+        if profile_name == '_default':
+            continue
+
+        account_uid = profile_data.get('account_uid', 'N/A')
+        project_uid = profile_data.get('project_uid', 'N/A')
+        region = profile_data.get('project_region', 'N/A')
+        environment = profile_data.get('environment', 'production')
+
+        default_indicator = " (default)" if profile_name == default_profile else ""
+        print(f"  - {profile_name}{default_indicator}")
+        print(f"    Account: {account_uid}")
+        print(f"    Project: {project_uid}")
+        print(f"    Region: {region}")
+        print(f"    Environment: {environment}")
+        print()
+
+
+def main():
+    """Main function to run the CLI tool."""
+    parser = argparse.ArgumentParser(
+        description='Execute SQL commands against Onehouse API',
+        epilog='Examples:\n'
+               '  Execute command: onehouse-cli --command "ALTER OCU SET LIMIT = \'3\'" --profile myprofile\n'
+               '  Check status: onehouse-cli --check-status REQUEST_ID --profile myprofile',
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+
+    parser.add_argument(
+        '--command', '-c',
+        type=str,
+        help='SQL command to execute (backticks around job IDs will be preserved automatically)'
+    )
+
+    parser.add_argument(
+        '--profile', '-p',
+        type=str,
+        help='Profile name to use for authentication (uses default if not specified)'
+    )
+
+    parser.add_argument(
+        '--list-profiles', '-l',
+        action='store_true',
+        help='List all available profiles'
+    )
+
+    parser.add_argument(
+        '--timeout', '-t',
+        type=int,
+        default=10,
+        help='Timeout in minutes for command completion (default: 10)'
+    )
+
+    parser.add_argument(
+        '--check-status',
+        type=str,
+        help='Check the status of an existing request by providing its request ID'
+    )
+
+    args = parser.parse_args()
+
+    # Load credentials
+    credentials = load_credentials()
+    if not credentials:
+        return 1
+
+    # List profiles if requested
+    if args.list_profiles:
+        list_profiles(credentials)
+        return 0
+
+    # Handle check-status if requested
+    if args.check_status:
+        # Handle profile selection for status check
+        profile_name = args.profile
+        if not profile_name:
+            # Check if there's a default profile set
+            if '_default' in credentials:
+                profile_name = credentials['_default']
+                print(f"Using default profile: {profile_name}")
+            else:
+                print("Error: --profile is required for status check")
+                print("\nUse --list-profiles to see available profiles")
+                print("Or run 'onehouse-cli-configure' to set up a default profile")
+                return 1
+
+        # Get profile credentials
+        profile_creds = get_profile_credentials(credentials, profile_name)
+        if not profile_creds:
+            return 1
+
+        # Store profile name for better error messages
+        profile_creds['name'] = profile_name
+
+        # Check status asynchronously
+        success = check_status_async(profile_creds, args.check_status)
+        return 0 if success else 1
+
+    # Validate required arguments for command execution
+    if not args.command:
+        print("Error: --command is required (unless using --check-status)")
+        parser.print_help()
+        return 1
+
+    # Handle profile selection
+    profile_name = args.profile
+    if not profile_name:
+        # Check if there's a default profile set
+        if '_default' in credentials:
+            profile_name = credentials['_default']
+            print(f"Using default profile: {profile_name}")
+        else:
+            print("Error: --profile is required")
+            print("\nUse --list-profiles to see available profiles")
+            print("Or run 'onehouse-cli-configure' to set up a default profile")
+            return 1
+
+    # Get profile credentials
+    profile_creds = get_profile_credentials(credentials, profile_name)
+    if not profile_creds:
+        return 1
+
+    # Store profile name for better error messages
+    profile_creds['name'] = profile_name
+
+    # Execute the command
+    success = execute_command(profile_creds, args.command, args.timeout)
+    return 0 if success else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

onehouse_cli/configure.py

@@ -0,0 +1,327 @@
+"""
+Onehouse CLI Configuration Tool
+Collects and stores Onehouse API credentials for future use.
+"""
+
+import os
+import json
+import getpass
+from pathlib import Path
+
+
+def get_user_input(prompt, secure=False):
+    """Get input from user with optional secure input for secrets."""
+    if secure:
+        return getpass.getpass(prompt)
+    return input(prompt).strip()
+
+
+def create_config_directory():
+    """Create the ~/.onehouse directory if it doesn't exist."""
+    config_dir = Path.home() / ".onehouse"
+    config_dir.mkdir(exist_ok=True)
+    return config_dir
+
+
+def load_existing_credentials():
+    """Load existing credentials file or return empty dict."""
+    credentials_file = Path.home() / ".onehouse" / "credentials"
+    if credentials_file.exists():
+        try:
+            with open(credentials_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+    return {}
+
+
+def save_credentials(credentials):
+    """Save credentials to ~/.onehouse/credentials file."""
+    config_dir = create_config_directory()
+    credentials_file = config_dir / "credentials"
+
+    with open(credentials_file, 'w') as f:
+        json.dump(credentials, f, indent=2)
+
+    # Set restrictive permissions (readable only by owner)
+    os.chmod(credentials_file, 0o600)
+
+
+def collect_credentials():
+    """Collect all required credentials from user."""
+    print("Onehouse CLI Configuration")
+    print("=" * 30)
+    print("Please provide your Onehouse API credentials:")
+    print()
+
+    credentials = {}
+
+    # Profile name
+    profile_name = get_user_input("Profile name: ")
+    if not profile_name:
+        print("Error: Profile name is required")
+        return None
+
+    # Load existing credentials to check if profile exists
+    existing_credentials = load_existing_credentials()
+    existing_profile = existing_credentials.get(profile_name, {})
+
+    if profile_name in existing_credentials:
+        print(f"\n⚠️  Profile '{profile_name}' already exists:")
+        print(f"    Account: {existing_profile.get('account_uid', 'N/A')}")
+        print(f"    Project: {existing_profile.get('project_uid', 'N/A')}")
+        print(f"    Region: {existing_profile.get('project_region', 'N/A')}")
+        print(f"    Environment: {existing_profile.get('environment', 'production')}")
+
+        # Show API Key/Secret previews in the summary
+        existing_key = existing_profile.get('api_key', '')
+        existing_secret = existing_profile.get('api_secret', '')
+        key_preview = existing_key[:4] + '...' if len(existing_key) > 4 else existing_key
+        secret_preview = existing_secret[:4] + '...' if len(existing_secret) > 4 else existing_secret
+        if existing_key:
+            print(f"    API Key: {key_preview}")
+        if existing_secret:
+            print(f"    API Secret: {secret_preview}")
+
+        print("\nPress Enter to keep existing values or enter new values:")
+
+    # Account UID
+    existing_account = existing_profile.get('account_uid', '')
+    prompt = f"Account UID ({existing_account}): " if existing_account else "Account UID: "
+    account_uid = get_user_input(prompt).strip()
+    if not account_uid:
+        if existing_account:
+            account_uid = existing_account
+        else:
+            print("Error: Account UID is required")
+            return None
+
+    # Project UID
+    existing_project = existing_profile.get('project_uid', '')
+    prompt = f"Project UID ({existing_project}): " if existing_project else "Project UID: "
+    project_uid = get_user_input(prompt).strip()
+    if not project_uid:
+        if existing_project:
+            project_uid = existing_project
+        else:
+            print("Error: Project UID is required")
+            return None
+
+    # API Key
+    existing_key = existing_profile.get('api_key', '')
+    key_preview = existing_key[:4] + '...' if len(existing_key) > 4 else existing_key
+    prompt = f"API Key ({key_preview}) (input masked): " if existing_key else "API Key (input masked): "
+    api_key = get_user_input(prompt, secure=True)
+    if not api_key:
+        if existing_key:
+            api_key = existing_key
+        else:
+            print("Error: API Key is required")
+            return None
+
+    # API Secret
+    existing_secret = existing_profile.get('api_secret', '')
+    secret_preview = existing_secret[:4] + '...' if len(existing_secret) > 4 else existing_secret
+    prompt = f"API Secret ({secret_preview}) (input masked): " if existing_secret else "API Secret (input masked): "
+    api_secret = get_user_input(prompt, secure=True)
+    if not api_secret:
+        if existing_secret:
+            api_secret = existing_secret
+        else:
+            print("Error: API Secret is required")
+            return None
+
+    # Project Region
+    existing_region = existing_profile.get('project_region', '')
+    prompt = f"Project Region ({existing_region}): " if existing_region else "Project Region: "
+    project_region = get_user_input(prompt).strip()
+    if not project_region:
+        if existing_region:
+            project_region = existing_region
+        else:
+            print("Error: Project Region is required")
+            return None
+
+    # User ID
+    existing_user = existing_profile.get('user_id', '')
+    prompt = f"User ID ({existing_user}): " if existing_user else "User ID: "
+    user_id = get_user_input(prompt).strip()
+    if not user_id:
+        if existing_user:
+            user_id = existing_user
+        else:
+            print("Error: User ID is required")
+            return None
+
+    # Request ID
+    existing_request = existing_profile.get('request_id', '')
+    prompt = f"Request ID ({existing_request}): " if existing_request else "Request ID: "
+    request_id = get_user_input(prompt).strip()
+    if not request_id:
+        if existing_request:
+            request_id = existing_request
+        else:
+            print("Error: Request ID is required")
+            return None
+
+    # Environment selection
+    existing_env = existing_profile.get('environment', 'production')
+    print()
+    print("Environment Selection:")
+    print("1. Production (api.onehouse.ai)")
+    print("2. Staging (staging-api.onehouse.ai)")
+    prompt = f"Choose environment (1 or 2) ({existing_env}): " if existing_env else "Choose environment (1 or 2): "
+    env_choice = get_user_input(prompt).strip()
+
+    if not env_choice and existing_env:
+        environment = existing_env
+        api_endpoint = existing_profile.get('api_endpoint',
+                                          'https://staging-api.onehouse.ai' if existing_env == 'staging'
+                                          else 'https://api.onehouse.ai')
+    elif env_choice == "2":
+        environment = "staging"
+        api_endpoint = "https://staging-api.onehouse.ai"
+    else:
+        environment = "production"
+        api_endpoint = "https://api.onehouse.ai"
+
+    print(f"Selected: {environment} environment")
+
+    credentials[profile_name] = {
+        "account_uid": account_uid,
+        "project_uid": project_uid,
+        "api_key": api_key,
+        "api_secret": api_secret,
+        "project_region": project_region,
+        "user_id": user_id,
+        "request_id": request_id,
+        "environment": environment,
+        "api_endpoint": api_endpoint
+    }
+
+    # Ask if this should be the default profile
+    print()
+    set_as_default = get_user_input("Set this as the default profile? (y/n): ").strip().lower()
+    if set_as_default in ['y', 'yes']:
+        credentials['_default'] = profile_name
+
+    return credentials, profile_name
+
+
+def is_already_in_shell_profile():
+    """Check if onehouse-cli is already added to shell profile."""
+    cli_dir = Path(__file__).parent.absolute()
+
+    # Detect shell and profile file
+    shell_profiles = [
+        Path.home() / ".zshrc",
+        Path.home() / ".bashrc",
+        Path.home() / ".bash_profile"
+    ]
+
+    for profile_file in shell_profiles:
+        if profile_file.exists():
+            try:
+                with open(profile_file, 'r') as f:
+                    content = f.read()
+                    if str(cli_dir) in content and "onehouse-cli" in content:
+                        return True
+            except IOError:
+                pass
+
+    return False
+
+
+def add_to_shell_profile():
+    """Add onehouse-cli tools to the user's shell profile."""
+    import subprocess
+
+    # Get the directory where the CLI tools are located
+    cli_dir = Path(__file__).parent.absolute()
+    path_export = f'export PATH="{cli_dir}:$PATH"'
+
+    # Detect shell and profile file
+    shell_profiles = [
+        Path.home() / ".zshrc",
+        Path.home() / ".bashrc",
+        Path.home() / ".bash_profile"
+    ]
+
+    profile_file = None
+    for profile in shell_profiles:
+        if profile.exists():
+            profile_file = profile
+            break
+
+    if not profile_file:
+        print("Could not find shell profile file (.zshrc, .bashrc, .bash_profile)")
+        print(f"Manually add this to your shell profile: {path_export}")
+        return
+
+    # Check if already added
+    try:
+        with open(profile_file, 'r') as f:
+            content = f.read()
+            if str(cli_dir) in content and "onehouse-cli" in content:
+                print(f"✓ Already added to {profile_file}")
+                return
+    except IOError:
+        pass
+
+    # Add to profile
+    try:
+        with open(profile_file, 'a') as f:
+            f.write(f"\n# Add onehouse-cli tools to PATH\n{path_export}\n")
+        print(f"✓ Added to {profile_file}")
+        print("Please run 'source ~/.zshrc' (or your shell profile) to apply changes")
+    except IOError as e:
+        print(f"Failed to write to {profile_file}: {e}")
+        print(f"Manually add this to your shell profile: {path_export}")
+
+
+def main():
+    """Main function to run the configuration tool."""
+    try:
+        # Load existing credentials
+        existing_credentials = load_existing_credentials()
+
+        # Collect new credentials
+        result = collect_credentials()
+        if not result:
+            return 1
+
+        new_credentials, profile_name = result
+
+        # Merge with existing credentials
+        existing_credentials.update(new_credentials)
+
+        # Save credentials
+        save_credentials(existing_credentials)
+
+        print()
+        print(f"✓ Profile '{profile_name}' configured successfully!")
+        print(f"Credentials saved to: {Path.home() / '.onehouse' / 'credentials'}")
+        print()
+
+        # Check if already in shell profile, only ask if not already added
+        if is_already_in_shell_profile():
+            print("✓ onehouse-cli tools already in shell PATH")
+        else:
+            add_to_profile = input("Add onehouse-cli tools to your shell PATH? (y/n): ").strip().lower()
+            if add_to_profile in ['y', 'yes']:
+                add_to_shell_profile()
+
+        print("You can now use this profile with future Onehouse CLI commands.")
+
+        return 0
+
+    except KeyboardInterrupt:
+        print("\n\nConfiguration cancelled.")
+        return 1
+    except Exception as e:
+        print(f"\nError: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    exit(main())

onehouse_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: onehouse-cli
+Version: 0.1.0
+Summary: A command-line tool for executing SQL commands against the Onehouse API
+Author-email: Sagar Lakshmipathy <18vidhyasagar@gmail.com>
+License: Other/Proprietary
+Keywords: onehouse,cli,sql
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+
+# Onehouse CLI
+
+A command-line tool for executing SQL commands against the Onehouse API with synchronous responses.
+
+## Setup
+1. **Create a virtual environment and install dependencies:**
+   ```bash
+   python3 -m venv venv
+   source venv/bin/activate
+   pip install -r requirements.txt
+   ```
+2. **Configure credentials:**
+   From withing the `onehouse-cli` directory, run:
+   ```bash
+   ./onehouse-cli-configure
+   ```
+   Prompts for: Profile name, Account UID, Project UID, API Key, API Secret, Project Region, User ID, Request ID, Environment (production or staging)
+   
+   **Note:** The tool will ask if you want to automatically add the CLI tools to your shell PATH for global access.
+
+3. **Credentials are stored in:** `~/.onehouse/credentials`
+
+## Usage
+
+**Execute SQL commands:**
+```bash
+onehouse-cli --command "SHOW LAKES" --profile myprofile
+```
+
+**List available profiles:**
+```bash
+onehouse-cli --list-profiles
+```
+
+**Custom timeout (default: 10 minutes):**
+```bash
+onehouse-cli --command "ALTER OCU SET LIMIT = '3'" --profile myprofile --timeout 5
+```
+
+## Features
+
+- **Synchronous execution**: Automatically polls for completion (1s intervals)
+- **Multiple profiles**: Store and switch between different API credentials
+- **Error handling**: Clear error messages with headers and response details
+- **Timeout control**: Configurable wait time for long-running operations
+- **Status checking**: Check the status of an existing request by providing its request ID
+
+## Examples
+
+```bash
+# Configure first profile
+./onehouse-cli-configure
+
+# Execute queries
+onehouse-cli --command "SHOW LAKES" --profile apex
+onehouse-cli --command "DELETE CLUSTER managed_cluster_retail" --profile apex
+
+# Manage profiles
+onehouse-cli --list-profiles
+
+# Check status of an existing request
+onehouse-cli --check-status "<REQUEST_ID>" --profile myprofile
+```

onehouse_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+onehouse_cli/__init__.py,sha256=0rXH4kKswcoeAxoVQqjPWjasPEoW4IOgWyM3YxjZjsM,242
+onehouse_cli/cli.py,sha256=rRDuBbqlOjrY39Jnf49jSNi1I4weKtAGioNjF5T4-rg,14134
+onehouse_cli/configure.py,sha256=68yyYCvwgAqXW8WZOrT_1UkpmXfu2JGEjNgxtXFYjHg,11172
+onehouse_cli-0.1.0.dist-info/METADATA,sha256=A-HlKcZq2thu1e8KS0XEYQRmaQ9QNDhQWd55ksRcId4,2628
+onehouse_cli-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onehouse_cli-0.1.0.dist-info/entry_points.txt,sha256=4htvgeLz-pkJyhtN2eqMyL3LyD9rJBrqhIjf6cqrMVE,108
+onehouse_cli-0.1.0.dist-info/top_level.txt,sha256=1C7mOY8nVumj1CWQP_MjotLh8RRPEGfd1JH8cFOf8k8,13
+onehouse_cli-0.1.0.dist-info/RECORD,,

onehouse_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

onehouse_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+onehouse-cli = onehouse_cli.cli:main
+onehouse-cli-configure = onehouse_cli.configure:main

onehouse_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+onehouse_cli