catocli 2.0.4__py3-none-any.whl → 2.0.5__py3-none-any.whl

build/lib/catocli/Utils/clidriver.py

@@ -0,0 +1,268 @@
+
+import os
+import argparse
+import json
+import catocli
+from graphql_client import Configuration
+from graphql_client.api_client import ApiException
+from ..parsers.parserApiClient import get_help
+from .profile_manager import get_profile_manager
+from .version_checker import check_for_updates, force_check_updates
+import traceback
+import sys
+sys.path.insert(0, 'vendor')
+import urllib3
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+# Initialize profile manager
+profile_manager = get_profile_manager()
+CATO_DEBUG = bool(os.getenv("CATO_DEBUG", False))
+from ..parsers.raw import raw_parse
+from ..parsers.custom import custom_parse
+from ..parsers.query_siteLocation import query_siteLocation_parse
+from ..parsers.mutation_accountManagement import mutation_accountManagement_parse
+from ..parsers.mutation_admin import mutation_admin_parse
+from ..parsers.mutation_container import mutation_container_parse
+from ..parsers.mutation_hardware import mutation_hardware_parse
+from ..parsers.mutation_policy import mutation_policy_parse
+from ..parsers.mutation_sandbox import mutation_sandbox_parse
+from ..parsers.mutation_site import mutation_site_parse
+from ..parsers.mutation_sites import mutation_sites_parse
+from ..parsers.mutation_xdr import mutation_xdr_parse
+from ..parsers.query_accountBySubdomain import query_accountBySubdomain_parse
+from ..parsers.query_accountManagement import query_accountManagement_parse
+from ..parsers.query_accountMetrics import query_accountMetrics_parse
+from ..parsers.query_accountRoles import query_accountRoles_parse
+from ..parsers.query_accountSnapshot import query_accountSnapshot_parse
+from ..parsers.query_admin import query_admin_parse
+from ..parsers.query_admins import query_admins_parse
+from ..parsers.query_appStats import query_appStats_parse
+from ..parsers.query_appStatsTimeSeries import query_appStatsTimeSeries_parse
+from ..parsers.query_auditFeed import query_auditFeed_parse
+from ..parsers.query_catalogs import query_catalogs_parse
+from ..parsers.query_container import query_container_parse
+from ..parsers.query_devices import query_devices_parse
+from ..parsers.query_entityLookup import query_entityLookup_parse
+from ..parsers.query_events import query_events_parse
+from ..parsers.query_eventsFeed import query_eventsFeed_parse
+from ..parsers.query_eventsTimeSeries import query_eventsTimeSeries_parse
+from ..parsers.query_hardware import query_hardware_parse
+from ..parsers.query_hardwareManagement import query_hardwareManagement_parse
+from ..parsers.query_licensing import query_licensing_parse
+from ..parsers.query_policy import query_policy_parse
+from ..parsers.query_sandbox import query_sandbox_parse
+from ..parsers.query_site import query_site_parse
+from ..parsers.query_subDomains import query_subDomains_parse
+from ..parsers.query_xdr import query_xdr_parse
+
+def show_version_info(args, configuration=None):
+	print(f"catocli version {catocli.__version__}")
+	
+	if not args.current_only:
+		if args.check_updates:
+			# Force check for updates
+			is_newer, latest_version, source = force_check_updates()
+		else:
+			# Regular check (uses cache)
+			is_newer, latest_version, source = check_for_updates(show_if_available=False)
+		
+		if latest_version:
+			if is_newer:
+				print(f"Latest version: {latest_version} (from {source}) - UPDATE AVAILABLE!")
+				print()
+				print("To upgrade, run:")
+				print("pip install --upgrade catocli")
+			else:
+				print(f"Latest version: {latest_version} (from {source}) - You are up to date!")
+		else:
+			print("Unable to check for updates (check your internet connection)")
+	return [{"success": True, "current_version": catocli.__version__, "latest_version": latest_version if not args.current_only else None}]
+
+def get_configuration(skip_api_key=False):
+	configuration = Configuration()
+	configuration.verify_ssl = False
+	configuration.debug = CATO_DEBUG
+	configuration.version = "{}".format(catocli.__version__)
+	
+	# Try to migrate from environment variables first
+	profile_manager.migrate_from_environment()
+	
+	# Get credentials from profile
+	credentials = profile_manager.get_credentials()
+	if not credentials:
+		print("No Cato CLI profile configured.")
+		print("Run 'catocli configure set' to set up your credentials.")
+		exit(1)
+
+	if not credentials.get('cato_token') or not credentials.get('account_id'):
+		profile_name = profile_manager.get_current_profile()
+		print(f"Profile '{profile_name}' is missing required credentials.")
+		print(f"Run 'catocli configure set --profile {profile_name}' to update your credentials.")
+		exit(1)
+	
+	# Only set API key if not using custom headers file
+	if not skip_api_key:
+		configuration.api_key["x-api-key"] = credentials['cato_token']
+	configuration.host = credentials['endpoint']
+	configuration.accountID = credentials['account_id']
+	
+	return configuration
+
+defaultReadmeStr = """
+The Cato CLI is a command-line interface tool designed to simplify the management and automation of Cato Networks’ configurations and operations. 
+It enables users to interact with Cato’s API for tasks such as managing Cato Management Application (CMA) site and account configurations, security policies, retrieving events, etc.
+
+
+For assistance in generating syntax for the cli to perform various operations, please refer to the Cato API Explorer application.
+
+
+https://github.com/catonetworks/cato-api-explorer
+"""
+
+parser = argparse.ArgumentParser(prog='catocli', usage='%(prog)s <operationType> <operationName> [options]', description=defaultReadmeStr)
+parser.add_argument('--version', action='version', version=catocli.__version__)
+parser.add_argument('-H', '--header', action='append', dest='headers', help='Add custom headers in "Key: Value" format. Can be used multiple times.')
+parser.add_argument('--headers-file', dest='headers_file', help='Load headers from a file. Each line should contain a header in "Key: Value" format.')
+subparsers = parser.add_subparsers()
+
+# Version command - enhanced with update checking
+version_parser = subparsers.add_parser('version', help='Show version information and check for updates')
+version_parser.add_argument('--check-updates', action='store_true', help='Force check for updates (ignores cache)')
+version_parser.add_argument('--current-only', action='store_true', help='Show only current version')
+version_parser.set_defaults(func=show_version_info)
+
+custom_parsers = custom_parse(subparsers)
+raw_parsers = subparsers.add_parser('raw', help='Raw GraphQL', usage=get_help("raw"))
+raw_parser = raw_parse(raw_parsers)
+query_parser = subparsers.add_parser('query', help='Query', usage='catocli query <operationName> [options]')
+query_subparsers = query_parser.add_subparsers(description='valid subcommands', help='additional help')
+query_siteLocation_parser = query_siteLocation_parse(query_subparsers)
+mutation_parser = subparsers.add_parser('mutation', help='Mutation', usage='catocli mutation <operationName> [options]')
+mutation_subparsers = mutation_parser.add_subparsers(description='valid subcommands', help='additional help')
+
+mutation_accountManagement_parser = mutation_accountManagement_parse(mutation_subparsers)
+mutation_admin_parser = mutation_admin_parse(mutation_subparsers)
+mutation_container_parser = mutation_container_parse(mutation_subparsers)
+mutation_hardware_parser = mutation_hardware_parse(mutation_subparsers)
+mutation_policy_parser = mutation_policy_parse(mutation_subparsers)
+mutation_sandbox_parser = mutation_sandbox_parse(mutation_subparsers)
+mutation_site_parser = mutation_site_parse(mutation_subparsers)
+mutation_sites_parser = mutation_sites_parse(mutation_subparsers)
+mutation_xdr_parser = mutation_xdr_parse(mutation_subparsers)
+query_accountBySubdomain_parser = query_accountBySubdomain_parse(query_subparsers)
+query_accountManagement_parser = query_accountManagement_parse(query_subparsers)
+query_accountMetrics_parser = query_accountMetrics_parse(query_subparsers)
+query_accountRoles_parser = query_accountRoles_parse(query_subparsers)
+query_accountSnapshot_parser = query_accountSnapshot_parse(query_subparsers)
+query_admin_parser = query_admin_parse(query_subparsers)
+query_admins_parser = query_admins_parse(query_subparsers)
+query_appStats_parser = query_appStats_parse(query_subparsers)
+query_appStatsTimeSeries_parser = query_appStatsTimeSeries_parse(query_subparsers)
+query_auditFeed_parser = query_auditFeed_parse(query_subparsers)
+query_catalogs_parser = query_catalogs_parse(query_subparsers)
+query_container_parser = query_container_parse(query_subparsers)
+query_devices_parser = query_devices_parse(query_subparsers)
+query_entityLookup_parser = query_entityLookup_parse(query_subparsers)
+query_events_parser = query_events_parse(query_subparsers)
+query_eventsFeed_parser = query_eventsFeed_parse(query_subparsers)
+query_eventsTimeSeries_parser = query_eventsTimeSeries_parse(query_subparsers)
+query_hardware_parser = query_hardware_parse(query_subparsers)
+query_hardwareManagement_parser = query_hardwareManagement_parse(query_subparsers)
+query_licensing_parser = query_licensing_parse(query_subparsers)
+query_policy_parser = query_policy_parse(query_subparsers)
+query_sandbox_parser = query_sandbox_parse(query_subparsers)
+query_site_parser = query_site_parse(query_subparsers)
+query_subDomains_parser = query_subDomains_parse(query_subparsers)
+query_xdr_parser = query_xdr_parse(query_subparsers)
+
+
+def parse_headers(header_strings):
+	headers = {}
+	if header_strings:
+		for header_string in header_strings:
+			if ':' not in header_string:
+				print(f"ERROR: Invalid header format '{header_string}'. Use 'Key: Value' format.")
+				exit(1)
+			key, value = header_string.split(':', 1)
+			headers[key.strip()] = value.strip()
+	return headers
+
+def parse_headers_from_file(file_path):
+	headers = {}
+	try:
+		with open(file_path, 'r') as f:
+			for line_num, line in enumerate(f, 1):
+				line = line.strip()
+				if not line or line.startswith('#'):
+					# Skip empty lines and comments
+					continue
+				if ':' not in line:
+					print(f"ERROR: Invalid header format in {file_path} at line {line_num}: '{line}'. Use 'Key: Value' format.")
+					exit(1)
+				key, value = line.split(':', 1)
+				headers[key.strip()] = value.strip()
+	except FileNotFoundError:
+		print(f"ERROR: Headers file '{file_path}' not found.")
+		exit(1)
+	except IOError as e:
+		print(f"ERROR: Could not read headers file '{file_path}': {e}")
+		exit(1)
+	return headers
+
+def main(args=None):
+	# Check if no arguments provided or help is requested
+	if args is None:
+		args = sys.argv[1:]
+
+	# Show version check when displaying help or when no command specified
+	if not args or '-h' in args or '--help' in args:
+		# Check for updates in background (non-blocking)
+		try:
+			check_for_updates(show_if_available=True)
+		except Exception:
+			# Don't let version check interfere with CLI operation
+			pass
+
+	args = parser.parse_args(args=args)
+	try:
+		# Skip authentication for configure commands
+		if hasattr(args, 'func') and hasattr(args.func, '__module__') and 'configure' in str(args.func.__module__):
+			response = args.func(args, None)
+		else:
+			# Check if using headers file to determine if we should skip API key
+			using_headers_file = hasattr(args, 'headers_file') and args.headers_file
+			
+			# Get configuration from profiles
+			configuration = get_configuration(skip_api_key=using_headers_file)
+			
+			# Parse custom headers if provided
+			custom_headers = {}
+			if hasattr(args, 'headers') and args.headers:
+				custom_headers.update(parse_headers(args.headers))
+			if hasattr(args, 'headers_file') and args.headers_file:
+				custom_headers.update(parse_headers_from_file(args.headers_file))
+			if custom_headers:
+				configuration.custom_headers.update(custom_headers)
+			# Handle account ID override
+			if args.func.__name__ != "createRawRequest":
+				if hasattr(args, 'accountID') and args.accountID is not None:
+					# Command line override takes precedence
+					configuration.accountID = args.accountID
+				# Otherwise use the account ID from the profile (already set in get_configuration)
+			response = args.func(args, configuration)
+
+		if type(response) == ApiException:
+			print("ERROR! Status code: {}".format(response.status))
+			print(response)
+		else:
+			if response!=None:
+				print(json.dumps(response[0], sort_keys=True, indent=4))
+	except Exception as e:
+		if isinstance(e, AttributeError):
+			print('Missing arguments. Usage: catocli <operation> -h')
+			if args.v==True:
+				print('ERROR: ',e)
+				traceback.print_exc()
+		else:
+			print('ERROR: ',e)
+			traceback.print_exc()
+		exit(1)

build/lib/catocli/Utils/profile_manager.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+Profile management for Cato CLI authentication
+Supports AWS CLI-style profiles with credentials stored in ~/.cato/credentials
+"""
+
+import os
+import configparser
+from pathlib import Path
+import sys
+
+
+class ProfileManager:
+    """Manages Cato CLI profiles and credentials"""
+    
+    def __init__(self):
+        self.cato_dir = Path.home() / '.cato'
+        self.credentials_file = self.cato_dir / 'credentials'
+        self.config_file = self.cato_dir / 'config'
+        self.default_endpoint = "https://api.catonetworks.com/api/v1/graphql2"
+        
+    def ensure_cato_directory(self):
+        """Ensure ~/.cato directory exists"""
+        self.cato_dir.mkdir(mode=0o700, exist_ok=True)
+        
+    def get_profile_config(self, profile_name='default'):
+        """Get configuration for a specific profile"""
+        if not self.credentials_file.exists():
+            return None
+            
+        config = configparser.ConfigParser()
+        config.read(self.credentials_file)
+        
+        if profile_name not in config:
+            return None
+            
+        profile_config = dict(config[profile_name])
+        
+        # Ensure required fields have defaults
+        if 'endpoint' not in profile_config:
+            profile_config['endpoint'] = self.default_endpoint
+            
+        return profile_config
+    
+    def list_profiles(self):
+        """List all available profiles"""
+        if not self.credentials_file.exists():
+            return []
+            
+        config = configparser.ConfigParser()
+        config.read(self.credentials_file)
+        return list(config.sections())
+    
+    def create_profile(self, profile_name, endpoint=None, cato_token=None, account_id=None):
+        """Create or update a profile"""
+        self.ensure_cato_directory()
+        
+        config = configparser.ConfigParser()
+        if self.credentials_file.exists():
+            config.read(self.credentials_file)
+        
+        if profile_name not in config:
+            config.add_section(profile_name)
+        
+        if endpoint:
+            config[profile_name]['endpoint'] = endpoint
+        elif 'endpoint' not in config[profile_name]:
+            config[profile_name]['endpoint'] = self.default_endpoint
+            
+        if cato_token:
+            config[profile_name]['cato_token'] = cato_token
+            
+        if account_id:
+            config[profile_name]['account_id'] = account_id
+        
+        with open(self.credentials_file, 'w') as f:
+            config.write(f)
+        
+        # Set secure permissions
+        os.chmod(self.credentials_file, 0o600)
+        
+        return True
+    
+    def delete_profile(self, profile_name):
+        """Delete a profile"""
+        if not self.credentials_file.exists():
+            return False
+            
+        config = configparser.ConfigParser()
+        config.read(self.credentials_file)
+        
+        if profile_name not in config:
+            return False
+            
+        config.remove_section(profile_name)
+        
+        with open(self.credentials_file, 'w') as f:
+            config.write(f)
+            
+        return True
+    
+    def get_current_profile(self):
+        """Get the current active profile name"""
+        # Check environment variable first
+        profile = os.getenv('CATO_PROFILE')
+        if profile:
+            return profile
+            
+        # Check config file
+        if self.config_file.exists():
+            config = configparser.ConfigParser()
+            config.read(self.config_file)
+            if 'default' in config and 'profile' in config['default']:
+                return config['default']['profile']
+        
+        return 'default'
+    
+    def set_current_profile(self, profile_name):
+        """Set the current active profile"""
+        self.ensure_cato_directory()
+        
+        config = configparser.ConfigParser()
+        if self.config_file.exists():
+            config.read(self.config_file)
+        
+        if 'default' not in config:
+            config.add_section('default')
+            
+        config['default']['profile'] = profile_name
+        
+        with open(self.config_file, 'w') as f:
+            config.write(f)
+            
+        return True
+    
+    def get_credentials(self, profile_name=None):
+        """Get credentials for the specified or current profile"""
+        if profile_name is None:
+            profile_name = self.get_current_profile()
+            
+        profile_config = self.get_profile_config(profile_name)
+        if not profile_config:
+            return None
+            
+        return {
+            'endpoint': profile_config.get('endpoint', self.default_endpoint),
+            'cato_token': profile_config.get('cato_token'),
+            'account_id': profile_config.get('account_id')
+        }
+    
+    def validate_profile(self, profile_name=None):
+        """Validate that a profile has all required credentials"""
+        credentials = self.get_credentials(profile_name)
+        if not credentials:
+            return False, f"Profile '{profile_name or self.get_current_profile()}' not found"
+            
+        missing = []
+        if not credentials.get('cato_token'):
+            missing.append('cato_token')
+        if not credentials.get('account_id'):
+            missing.append('account_id')
+            
+        if missing:
+            return False, f"Profile missing required fields: {', '.join(missing)}"
+            
+        return True, "Profile is valid"
+    
+    def migrate_from_environment(self):
+        """Migrate from environment variables to default profile if needed"""
+        cato_token = os.getenv('CATO_TOKEN')
+        account_id = os.getenv('CATO_ACCOUNT_ID')
+        
+        if cato_token and account_id:
+            # Check if default profile already exists
+            default_config = self.get_profile_config('default')
+            if not default_config:
+                print("Migrating environment variables to default profile...")
+                self.create_profile('default', 
+                                 endpoint=self.default_endpoint,
+                                 cato_token=cato_token, 
+                                 account_id=account_id)
+                return True
+        return False
+
+
+def get_profile_manager():
+    """Get a ProfileManager instance"""
+    return ProfileManager()

build/lib/catocli/Utils/version_checker.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""
+Version checking utility for Cato CLI
+Checks for newer versions available on GitHub releases and PyPI
+"""
+
+import json
+import urllib.request
+import urllib.error
+import ssl
+import os
+import time
+from .. import __version__
+
+# Cache settings
+CACHE_FILE = os.path.expanduser("~/.catocli_version_cache")
+CACHE_DURATION = 3600 * 24  # 24 hours in seconds
+
+def get_cached_version_info():
+    """Get cached version information if still valid"""
+    try:
+        if os.path.exists(CACHE_FILE):
+            with open(CACHE_FILE, 'r') as f:
+                cache_data = json.load(f)
+            
+            # Check if cache is still valid
+            if time.time() - cache_data.get('timestamp', 0) < CACHE_DURATION:
+                return cache_data.get('latest_version'), cache_data.get('source')
+    except (json.JSONDecodeError, OSError):
+        pass
+    return None, None
+
+def cache_version_info(latest_version, source):
+    """Cache version information"""
+    try:
+        cache_data = {
+            'latest_version': latest_version,
+            'source': source,
+            'timestamp': time.time()
+        }
+        with open(CACHE_FILE, 'w') as f:
+            json.dump(cache_data, f)
+    except OSError:
+        pass  # Fail silently if we can't write cache
+
+def get_latest_github_version():
+    """Get the latest version from GitHub releases"""
+    try:
+        # Create SSL context that doesn't verify certificates (for corporate networks)
+        context = ssl.create_default_context()
+        context.check_hostname = False
+        context.verify_mode = ssl.CERT_NONE
+        
+        url = "https://api.github.com/repos/catonetworks/cato-cli/releases/latest"
+        req = urllib.request.Request(url)
+        req.add_header('User-Agent', f'catocli/{__version__}')
+        
+        with urllib.request.urlopen(req, context=context, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            tag_name = data.get('tag_name', '')
+            # Remove 'v' prefix if present
+            if tag_name.startswith('v'):
+                tag_name = tag_name[1:]
+            return tag_name
+    except (urllib.error.URLError, urllib.error.HTTPError, json.JSONDecodeError, KeyError):
+        return None
+
+def get_latest_pypi_version():
+    """Get the latest version from PyPI"""
+    try:
+        # Create SSL context that doesn't verify certificates (for corporate networks)
+        context = ssl.create_default_context()
+        context.check_hostname = False
+        context.verify_mode = ssl.CERT_NONE
+        
+        url = "https://pypi.org/pypi/catocli/json"
+        req = urllib.request.Request(url)
+        req.add_header('User-Agent', f'catocli/{__version__}')
+        
+        with urllib.request.urlopen(req, context=context, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            return data['info']['version']
+    except (urllib.error.URLError, urllib.error.HTTPError, json.JSONDecodeError, KeyError):
+        return None
+
+def get_latest_version():
+    """Get the latest version available from GitHub or PyPI"""
+    # Check cache first
+    cached_version, cached_source = get_cached_version_info()
+    if cached_version:
+        return cached_version, cached_source
+    
+    # Try GitHub first (usually more up-to-date for development releases)
+    github_version = get_latest_github_version()
+    if github_version:
+        cache_version_info(github_version, 'GitHub')
+        return github_version, 'GitHub'
+    
+    # Fall back to PyPI
+    pypi_version = get_latest_pypi_version()
+    if pypi_version:
+        cache_version_info(pypi_version, 'PyPI')
+        return pypi_version, 'PyPI'
+    
+    return None, None
+
+def compare_versions(version1, version2):
+    """Compare two version strings. Returns 1 if version1 > version2, -1 if version1 < version2, 0 if equal"""
+    def version_tuple(v):
+        # Convert version string to tuple of integers for comparison
+        # Handle versions like "1.0.20", "1.0.20-beta", etc.
+        parts = v.split('-')[0].split('.')  # Remove pre-release suffixes
+        return tuple(int(x) for x in parts if x.isdigit())
+    
+    try:
+        v1_tuple = version_tuple(version1)
+        v2_tuple = version_tuple(version2)
+        
+        # Pad shorter version with zeros
+        max_len = max(len(v1_tuple), len(v2_tuple))
+        v1_tuple += (0,) * (max_len - len(v1_tuple))
+        v2_tuple += (0,) * (max_len - len(v2_tuple))
+        
+        if v1_tuple > v2_tuple:
+            return 1
+        elif v1_tuple < v2_tuple:
+            return -1
+        else:
+            return 0
+    except (ValueError, AttributeError):
+        return 0  # If we can't parse, assume they're equal
+
+def is_newer_version_available():
+    """Check if a newer version is available"""
+    try:
+        latest_version, source = get_latest_version()
+        if latest_version:
+            comparison = compare_versions(latest_version, __version__)
+            return comparison > 0, latest_version, source
+    except Exception:
+        pass  # Fail silently for any version parsing errors
+    
+    return False, None, None
+
+def show_upgrade_message(latest_version, source):
+    """Display upgrade message to user"""
+    print()
+    print("─" * 60)
+    print(f"🚀 A newer version of catocli is available!")
+    print(f"   Current version: {__version__}")
+    print(f"   Latest version:  {latest_version} (from {source})")
+    print()
+    if source == 'PyPI':
+        print("   To upgrade, run:")
+        print("   pip install --upgrade catocli")
+    else:
+        print("   To upgrade, run:")
+        print("   pip install --upgrade catocli")
+        print("   (or check GitHub releases for pre-release versions)")
+    print("─" * 60)
+    print()
+
+def check_for_updates(show_if_available=True):
+    """
+    Check for updates and optionally show upgrade message
+    
+    Args:
+        show_if_available (bool): Whether to show the upgrade message if update is available
+    
+    Returns:
+        tuple: (is_newer_available, latest_version, source)
+    """
+    try:
+        is_newer, latest_version, source = is_newer_version_available()
+        
+        if is_newer and show_if_available:
+            show_upgrade_message(latest_version, source)
+        
+        return is_newer, latest_version, source
+    except Exception:
+        # Fail silently - don't interrupt the user's workflow
+        return False, None, None
+
+def force_check_updates():
+    """Force check for updates by clearing cache"""
+    try:
+        if os.path.exists(CACHE_FILE):
+            os.remove(CACHE_FILE)
+    except OSError:
+        pass
+    
+    return check_for_updates(show_if_available=True)

build/lib/catocli/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "2.0.5"
+__cato_host__ = "https://api.catonetworks.com/api/v1/graphql2"

build/lib/catocli/__main__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+import sys
+from .Utils import clidriver
+
+def main():
+	if sys.argv.__len__() == 1:
+		print('Usage: catocli -h')
+	else:
+		sys.exit(clidriver.main(sys.argv[1:]))
+
+if __name__ == '__main__':
+	main()