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

schema/catolib.py

@@ -200,7 +200,7 @@ def getNestedArgDefinitions(argsAry, parentParamPath, childOperations, parentFie
 	# print("getNestedArgDefinitions()",newArgsList.keys())
 	return newArgsList
 
-def getOfType(curType, ofType, parentParamPath, childOperations, parentFields):
+def getOfType(curType, ofType, parentParamPath, childOperations, parentFields, parentTypeName=None):
 	ofType["kind"].append(copy.deepcopy(curType["kind"]))
 	curParamPath = "" if (parentParamPath == None) else parentParamPath + "___"
 	if curType["ofType"] != None:
@@ -216,7 +216,7 @@ def getOfType(curType, ofType, parentParamPath, childOperations, parentFields):
 		ofType["indexType"] = "input_object"
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["input_objects"][ofType["name"]])
 		if ofType["definition"]["inputFields"] != None:
-			ofType["definition"]["inputFields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["inputFields"]), curParamPath, childOperations, parentFields)
+			ofType["definition"]["inputFields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["inputFields"]), curParamPath, childOperations, parentFields, ofType["name"])
 	elif "UNION" in ofType["kind"]:
 		ofType["indexType"] = "interface"
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["unions"][ofType["name"]])
@@ -243,14 +243,14 @@ def getOfType(curType, ofType, parentParamPath, childOperations, parentFields):
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["objects"][ofType["name"]])
 		if ofType["definition"]["fields"] != None and childOperations!=None:
 			ofType["definition"]["fields"] = checkForChildOperation(copy.deepcopy(ofType["definition"]["fields"]),childOperations)
-			ofType["definition"]["fields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["fields"]), curParamPath,childOperations, parentFields)
+			ofType["definition"]["fields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["fields"]), curParamPath,childOperations, parentFields, ofType["name"])
 		if ofType["definition"]["interfaces"] != None:
 			ofType["definition"]["interfaces"] = getNestedInterfaceDefinitions(copy.deepcopy(ofType["definition"]["interfaces"]), curParamPath,childOperations, parentFields)
 	elif "INTERFACE" in ofType["kind"]:
 		ofType["indexType"] = "interface"
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["interfaces"][ofType["name"]])
 		if ofType["definition"]["fields"] != None:
-			ofType["definition"]["fields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["fields"]), curParamPath, childOperations, parentFields)
+			ofType["definition"]["fields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["fields"]), curParamPath, childOperations, parentFields, ofType["name"])
 		if ofType["definition"]["possibleTypes"] != None:
 			ofType["definition"]["possibleTypes"] = getNestedInterfaceDefinitions(copy.deepcopy(ofType["definition"]["possibleTypes"]), curParamPath, childOperations, parentFields)
 			for interfaceName in ofType["definition"]["possibleTypes"]:
@@ -277,14 +277,14 @@ def getOfType(curType, ofType, parentParamPath, childOperations, parentFields):
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["enums"][ofType["name"]])
 	return ofType
 
-def getNestedFieldDefinitions(fieldsAry, parentParamPath,childOperations, parentFields):
+def getNestedFieldDefinitions(fieldsAry, parentParamPath,childOperations, parentFields, parentTypeName=None):
 	newFieldsList = {}
 	for field in fieldsAry:
 		if isinstance(field,str):
 			field = fieldsAry[field]
 		curParamPath = field["name"] if (parentParamPath == None) else (parentParamPath.replace("___",".") + field["name"])
 		# curParamPath = field["name"] if (parentParamPath == None) else (parentParamPath + "." + field["name"])
-		field["type"] = getOfType(field["type"], { "non_null": False, "kind": [], "name": None }, curParamPath,childOperations, parentFields)
+		field["type"] = getOfType(field["type"], { "non_null": False, "kind": [], "name": None }, curParamPath,childOperations, parentFields, parentTypeName)
 		field["path"] = curParamPath
 		field["id_str"] = curParamPath.replace(".","___")
 		if isinstance(field["type"]["kind"], list):
@@ -312,7 +312,11 @@ def getNestedFieldDefinitions(fieldsAry, parentParamPath,childOperations, parent
 				# print(json.dumps(field,indent=2,sort_keys=True))
 				# print(field["path"],parentFields)
 			# field["alias"] = renderCamelCase(field["type"]["name"]+"."+field["name"])+": "+field["name"]
-			field["alias"] = renderCamelCase(field["type"]["name"]+"."+field["name"])+": "+field["name"]
+			# Use parent type name instead of field type name for alias
+			if parentTypeName:
+				field["alias"] = renderCamelCase(field["name"]+"."+parentTypeName)+": "+field["name"]
+			else:
+				field["alias"] = renderCamelCase(field["type"]["name"]+"."+field["name"])+": "+field["name"]
 		if "records.fields" not in field["path"]:
 			newFieldsList[field["name"]] = field	
 	# for (fieldPath in newFieldList) {
@@ -333,9 +337,9 @@ def getNestedInterfaceDefinitions(possibleTypesAry, parentParamPath,childOperati
 		curInterface = curInterfaces[curInterfaceName]
 		curParamPath = "" if parentParamPath == None else parentParamPath + curInterface["name"] + "___"
 		if "fields" in curInterface and curInterface["fields"] != None:
-			curInterface["fields"] = getNestedFieldDefinitions(copy.deepcopy(curInterface["fields"]), curParamPath,childOperations, parentFields)
+			curInterface["fields"] = getNestedFieldDefinitions(copy.deepcopy(curInterface["fields"]), curParamPath,childOperations, parentFields, curInterface["name"])
 		if "inputFields" in curInterface and curInterface["inputFields"] != None:
-			curInterface["inputFields"] = getNestedFieldDefinitions(copy.deepcopy(curInterface["inputFields"]), curParamPath,childOperations, parentFields)
+			curInterface["inputFields"] = getNestedFieldDefinitions(copy.deepcopy(curInterface["inputFields"]), curParamPath,childOperations, parentFields, curInterface["name"])
 		if "interfaces" in curInterface and curInterface["interfaces"] != None:
 			curInterface["interfaces"] = getNestedInterfaceDefinitions(copy.deepcopy(curInterface["interfaces"]), curParamPath,childOperations, parentFields)
 		if "possibleTypes" in curInterface and curInterface["possibleTypes"] != None:
@@ -357,10 +361,10 @@ def parseOperation(curOperation,childOperations):
 			# for field in curOperation["type"]["definition"]["fields"]:
 			# 	parentFields.append(field["name"])
 			curOperation["type"]["definition"]["fields"] = checkForChildOperation(copy.deepcopy(curOperation["type"]["definition"]["fields"]),childOperations)
-			curOperation["type"]["definition"]["fields"] = copy.deepcopy(getNestedFieldDefinitions(curOperation["type"]["definition"]["fields"], None,childOperations,[]))
+			curOperation["type"]["definition"]["fields"] = copy.deepcopy(getNestedFieldDefinitions(curOperation["type"]["definition"]["fields"], None,childOperations,[], curOperation["type"]["name"]))
 		if "inputFields" in curOperation["type"]["definition"] and curOperation["type"]["definition"]["inputFields"] != None:
 			parentFields = curOperation["type"]["definition"]["inputFields"].keys()
-			curOperation["type"]["definition"]["inputFields"] = copy.deepcopy(getNestedFieldDefinitions(curOperation["type"]["definition"]["inputFields"], None,childOperations,parentFields))
+			curOperation["type"]["definition"]["inputFields"] = copy.deepcopy(getNestedFieldDefinitions(curOperation["type"]["definition"]["inputFields"], None,childOperations,parentFields, curOperation["type"]["name"]))
 	return curOperation
 
 def checkForChildOperation(fieldsAry,childOperations):
@@ -1076,7 +1080,12 @@ def renderArgsAndFields(responseArgStr, variablesObj, curOperation, definition,
 			responseArgStr += " {\n"
 			for subfieldIndex in field['type']['definition']['fields']:
 				subfield = field['type']['definition']['fields'][subfieldIndex]
-				subfield_name = subfield['alias'] if 'alias' in subfield else subfield['name']				
+				# updated logic: use fieldTypes to determine if aliasing is needed
+				if (subfield['type']['name'] in curOperation.get('fieldTypes', {}) and 
+					'SCALAR' not in subfield['type'].get('kind', [])):
+					subfield_name = subfield['name'] + field['type']['definition']['name'] + ": " + subfield['name']
+				else:
+					subfield_name = subfield['alias'] if 'alias' in subfield else subfield['name']
 				responseArgStr += indent + "	" + subfield_name
 				if subfield.get("args") and len(list(subfield["args"].keys()))>0:
 					argsPresent = False

build/lib/catocli/Utils/clidriver.py

@@ -1,268 +0,0 @@
-
-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

@@ -1,188 +0,0 @@
-#!/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()