Add Developer CLI (#111)

Author: simonkurtz-MSFT

README.md

@@ -76,6 +76,38 @@ These prerequisites apply broadly across all infrastructure and samples. If ther
 
 ### 🛠️ Initialization
 
+#### 🚀 Developer CLI
+
+Use the interactive Developer CLI to verify setup, run tests, and manage your development workflow:
+
+**Windows:**
+```powershell
+.\start.ps1
+```
+
+**macOS / Linux:**
+```bash
+./start.sh
+```
+
+This menu-driven interface provides quick access to:
+- **Setup**: Complete environment setup, verify local setup, show Azure account info
+- **Tests**: Run pylint, run pytest suite, run full Python checks
+- **Misc**: Exit the CLI
+
+Example output from option 2 (Verify local setup):
+```
+🔍 APIM Samples Local Environment Verification
+✅ Virtual environment is active
+✅ All required packages installed
+✅ Shared modules can be imported
+✅ .env file configured
+⚠️  Jupyter kernel not found
+✅ VS Code settings configured
+```
+
+---
+
 #### Using Dev Container (Recommended)
 
 If you're using the dev container (GitHub Codespaces or VS Code Dev Containers):

setup/setup_python_path.py

@@ -16,16 +16,94 @@
 
 import sys
 import subprocess
+import shutil
 import os
 import json
 from pathlib import Path  # Cross-platform path handling (Windows: \, Unix: /)
+import subprocess  # Ensure subprocess is imported for the new functions
 
 
 DEFAULT_VSCODE_SEARCH_EXCLUDE = {
     "**/.venv": True,
     "**/.venv/**": True,
 }
 
+def check_azure_cli_installed():
+    """Check if Azure CLI is installed."""
+    az_path = shutil.which('az') or shutil.which('az.cmd') or shutil.which('az.bat')
+    if not az_path:
+        print("   ❌ Azure CLI is not installed. Please install from: https://learn.microsoft.com/cli/azure/install-azure-cli")
+        return False
+    try:
+        subprocess.run([az_path, '--version'], capture_output=True, text=True, check=True)
+        print("   ✅ Azure CLI is installed")
+        return True
+    except subprocess.CalledProcessError:
+        print("   ❌ Azure CLI is not installed. Please install from: https://learn.microsoft.com/cli/azure/install-azure-cli")
+        return False
+
+def check_bicep_cli_installed():
+    """Check if Azure Bicep CLI is installed."""
+    az_path = shutil.which('az') or shutil.which('az.cmd') or shutil.which('az.bat')
+    if not az_path:
+        print("   ❌ Azure CLI is not installed. Please install from: https://learn.microsoft.com/cli/azure/install-azure-cli")
+        return False
+
+    try:
+        subprocess.run([az_path, 'bicep', 'version'], capture_output=True, text=True, check=True)
+        print("   ✅ Azure Bicep CLI is installed (via az bicep)")
+        return True
+    except subprocess.CalledProcessError:
+        print("   ❌ Azure Bicep CLI is not installed. Install with: az bicep install")
+        return False
+
+def check_azure_providers_registered():
+    """Check if required Azure resource providers are registered in the current subscription."""
+    az_path = shutil.which('az') or shutil.which('az.cmd') or shutil.which('az.bat')
+    if not az_path:
+        print("   ❌ Azure CLI is not installed. Please install from: https://learn.microsoft.com/cli/azure/install-azure-cli")
+        return False
+    required_providers = [
+        'Microsoft.ApiManagement',
+        'Microsoft.App',
+        'Microsoft.Authorization',
+        'Microsoft.CognitiveServices',
+        'Microsoft.ContainerRegistry',
+        'Microsoft.KeyVault',
+        'Microsoft.Maps',
+        'Microsoft.ManagedIdentity',
+        'Microsoft.Network',
+        'Microsoft.OperationalInsights',
+        'Microsoft.Resources',
+        'Microsoft.Storage'
+    ]
+
+    try:
+        # Get list of registered providers
+        result = subprocess.run(
+            [az_path, 'provider', 'list', '--query', '[].namespace', '-o', 'json'],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        registered_providers = json.loads(result.stdout)
+
+        missing_providers = [p for p in required_providers if p not in registered_providers]
+
+        if not missing_providers:
+            print("   ✅ All required Azure resource providers are registered")
+            return True
+
+        print(f"   ❌ Missing {len(missing_providers)} Azure provider(s):")
+        for provider in missing_providers:
+            print(f"      • {provider}")
+        print("   Register with: az provider register -n <provider-namespace>")
+        return False
+
+    except (subprocess.CalledProcessError, json.JSONDecodeError, FileNotFoundError):
+        print("   ⚠️  Could not verify Azure provider registrations (Azure CLI may not be configured)")
+        return False
+
 DEFAULT_VSCODE_FILES_WATCHER_EXCLUDE = {
     "**/.venv/**": True,
 }
@@ -549,16 +627,26 @@ def force_kernel_consistency():
 
 def setup_complete_environment():
     """
-    Complete setup: generate .env file, register kernel, and configure VS Code.
+    Complete setup: check Azure prerequisites, generate .env file, register kernel, and configure VS Code.
 
     This provides a one-command setup that makes the local environment
     as easy to use as the dev container.
     """
 
     print("🚀 Setting up complete APIM Samples environment...\n")
 
+    # Step 0: Check Azure prerequisites
+    print("0. Checking Azure prerequisites...")
+    azure_cli_ok = check_azure_cli_installed()
+    bicep_ok = check_bicep_cli_installed()
+    providers_ok = check_azure_providers_registered()
+
+    if not (azure_cli_ok and bicep_ok and providers_ok):
+        print("\n⚠️  Some Azure prerequisites are missing. Please address the issues above and re-run this script.")
+        return
+
     # Step 1: Generate .env file
-    print("1. Generating .env file for Python path configuration...")
+    print("\n1. Generating .env file for Python path configuration...")
     generate_env_file()
 
     # Step 2: Register Jupyter kernel
@@ -576,6 +664,8 @@ def setup_complete_environment():
     # Summary
     print("\n" + "="*50)
     print("📋 Setup Summary:")
+    print("   ✅ Azure CLI and Bicep: Available")
+    print("   ✅ Azure resource providers: Registered")
     print("   ✅ Python path configuration: Complete")
     print(f"   {'✅' if kernel_success else '❌'} Jupyter kernel registration: {'Complete' if kernel_success else 'Failed'}")
     print(f"   {'✅' if vscode_success else '❌'} VS Code settings: {'Complete' if vscode_success else 'Failed'}")

setup/verify_local_setup.py

@@ -6,6 +6,8 @@
 - Virtual environment is active
 - Required packages are installed
 - Shared modules can be imported
+- Azure CLI and Bicep CLI are installed
+- Required Azure resource providers are registered
 - Jupyter kernel is registered
 - VS Code settings are configured
 
@@ -15,8 +17,15 @@
 import sys
 import subprocess
 import os
+import io
+import json
+import shutil
 from pathlib import Path
 
+# Configure UTF-8 encoding for console output
+if sys.stdout.encoding != 'utf-8':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
 
 def print_status(message, success=True):
     """Print status message with colored output."""
@@ -179,6 +188,92 @@ def check_env_file():
         return False
 
 
+def check_azure_cli():
+    """Check if Azure CLI is installed."""
+    az_path = shutil.which('az') or shutil.which('az.cmd') or shutil.which('az.bat')
+    if not az_path:
+        print_status("Azure CLI is not installed or not in PATH", False)
+        return False
+    try:
+        result = subprocess.run([az_path, '--version'], capture_output=True, text=True, check=True)
+        version_line = (result.stdout.splitlines() or ["unknown version"])[0].strip()
+        print_status(f"Azure CLI is installed ({version_line})")
+        return True
+    except subprocess.CalledProcessError:
+        print_status("Azure CLI is not installed or not in PATH", False)
+        return False
+
+
+def check_bicep_cli():
+    """Check if Azure Bicep CLI is installed."""
+    az_path = shutil.which('az') or shutil.which('az.cmd') or shutil.which('az.bat')
+    if not az_path:
+        print_status("Azure CLI is not installed or not in PATH", False)
+        return False
+
+    try:
+        result = subprocess.run([az_path, 'bicep', 'version'], capture_output=True, text=True, check=True)
+        version_line = (result.stdout.splitlines() or ["unknown version"])[0].strip()
+        print_status(f"Azure Bicep CLI is installed (az bicep version: {version_line})")
+        return True
+    except subprocess.CalledProcessError:
+        print_status("Azure Bicep CLI is not installed. Install with: az bicep install", False)
+        return False
+
+
+def check_azure_providers():
+    """Check if required Azure resource providers are registered in the current subscription."""
+    az_path = shutil.which('az') or shutil.which('az.cmd') or shutil.which('az.bat')
+    if not az_path:
+        print_status("Azure CLI is not installed or not in PATH", False)
+        return False
+    required_providers = [
+        'Microsoft.ApiManagement',
+        'Microsoft.App',
+        'Microsoft.Authorization',
+        'Microsoft.CognitiveServices',
+        'Microsoft.ContainerRegistry',
+        'Microsoft.KeyVault',
+        'Microsoft.Maps',
+        'Microsoft.ManagedIdentity',
+        'Microsoft.Network',
+        'Microsoft.OperationalInsights',
+        'Microsoft.Resources',
+        'Microsoft.Storage'
+    ]
+
+    try:
+        # Get list of registered providers
+        result = subprocess.run(
+            [az_path, 'provider', 'list', '--query', '[].namespace', '-o', 'json'],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        registered_providers = sorted(set(json.loads(result.stdout)))
+
+        missing_providers = [p for p in required_providers if p not in registered_providers]
+        found_providers = [p for p in required_providers if p in registered_providers]
+
+        print("   Registered providers:")
+        for provider in found_providers:
+            print(f"      - {provider}")
+
+        if not missing_providers:
+            print_status("All required Azure providers are registered")
+            return True
+
+        print_status(f"Missing {len(missing_providers)} provider(s): {', '.join(missing_providers)}", False)
+        print("   Register missing providers with:")
+        for provider in missing_providers:
+            print(f"   az provider register -n {provider}")
+        return False
+
+    except (subprocess.CalledProcessError, json.JSONDecodeError, FileNotFoundError):
+        print_status("Could not verify Azure provider registrations", False)
+        return False
+
+
 def main():
     """Run all verification checks."""
     print("🔍 APIM Samples Local Environment Verification")
@@ -189,6 +284,9 @@ def main():
         ("Required Packages", check_required_packages),
         ("Shared Modules", check_shared_modules),
         ("Environment File", check_env_file),
+        ("Azure CLI", check_azure_cli),
+        ("Azure Bicep CLI", check_bicep_cli),
+        ("Azure Providers", check_azure_providers),
         ("Jupyter Kernel", check_jupyter_kernel),
         ("VS Code Settings", check_vscode_settings)
     ]

shared/python/console.py

@@ -156,7 +156,8 @@ def _print_log(message: str, prefix: str = '', color: str = '', output: str = ''
 
 def print_command(cmd: str = '') -> None:
     """Print a command message."""
-    _print_log(cmd, '⚙️ ', BOLD_B, blank_above = True, blank_below = True, level = logging.INFO)
+    # Two spaces after the cog as opposed to one elsewhere are intentional for formatting. Please don't change this.
+    _print_log(cmd, '⚙️  ', BOLD_B, blank_above = True, blank_below = True, level = logging.INFO)
 
 def print_error(msg: str, output: str = '', duration: str = '') -> None:
     """Print an error message."""
@@ -180,7 +181,7 @@ def print_warning(msg: str, output: str = '', duration: str = '') -> None:
 
 def print_val(name: str, value: str, val_below: bool = False) -> None:
     """Print a key-value pair."""
-    _print_log(f"{name:<25}:{'\n' if val_below else ' '}{value}", '👉🏽 ', BOLD_B, wrap_lines = True, level = logging.INFO)
+    _print_log(f"{name:<25}:{'\n' if val_below else ' '}{value}", '👉 ', BOLD_B, wrap_lines = True, level = logging.INFO)
 
 def print_plain(msg: str = '', *, level: int | None = None, wrap_lines: bool = True, blank_above: bool = False, blank_below: bool = False) -> None:
     """Log a message without any icon/prefix.

shared/python/infrastructures.py

@@ -1248,7 +1248,7 @@ def _cleanup_resources_parallel(resources: list[dict], thread_prefix: str = '',
     def log_info(msg):
         if use_thread_safe_printing:
             with _print_lock:
-                _print_log(f"{thread_prefix}{msg}", '👉🏽 ', thread_color)
+                _print_log(f"{thread_prefix}{msg}", '👉 ', thread_color)
         else:
             print_info(msg)
 
@@ -1494,13 +1494,13 @@ def _cleanup_resources_thread_safe(deployment_name: str, rg_name: str, thread_pr
     """
     try:
         with _print_lock:
-            _print_log(f"{thread_prefix}Starting cleanup for resource group: {rg_name}", '👉🏽 ', thread_color)
+            _print_log(f"{thread_prefix}Starting cleanup for resource group: {rg_name}", '👉 ', thread_color)
 
         # Create a modified version of _cleanup_resources that uses thread-safe printing
         _cleanup_resources_with_thread_safe_printing(deployment_name, rg_name, thread_prefix, thread_color)
 
         with _print_lock:
-            _print_log(f"{thread_prefix}Completed cleanup for resource group: {rg_name}", '👉🏽 ', thread_color)
+            _print_log(f"{thread_prefix}Completed cleanup for resource group: {rg_name}", '👉 ', thread_color)
 
         return True, ""
 
@@ -1531,7 +1531,7 @@ def _cleanup_resources_with_thread_safe_printing(deployment_name: str, rg_name:
 
     try:
         with _print_lock:
-            _print_log(f"{thread_prefix}Resource group : {rg_name}", '👉🏽 ', thread_color)
+            _print_log(f"{thread_prefix}Resource group : {rg_name}", '👉 ', thread_color)
 
         # Show the deployment details
         output = az.run(
@@ -1596,13 +1596,13 @@ def _cleanup_resources_with_thread_safe_printing(deployment_name: str, rg_name:
             with _print_lock:
                 _print_log(
                     f"{thread_prefix}Found {len(resources_to_cleanup)} resource(s) to clean up. Processing in parallel...",
-                    '👉🏽 ',
+                    '👉 ',
                     thread_color
                 )
             _cleanup_resources_parallel_thread_safe(resources_to_cleanup, thread_prefix, thread_color)
         else:
             with _print_lock:
-                _print_log(f"{thread_prefix}No resources found to clean up.", '👉🏽 ', thread_color)
+                _print_log(f"{thread_prefix}No resources found to clean up.", '👉 ', thread_color)
 
         # Delete the resource group last
         rg_delete_attempted = True