machineconfig 1.94__py3-none-any.whl → 1.95__py3-none-any.whl

machineconfig/scripts/python/devops.py

@@ -5,6 +5,13 @@ from machineconfig.utils.utils import display_options, PROGRAM_PATH, write_shell
 from platform import system
 from enum import Enum
 from typing import Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich import box # Import box
+
+console = Console()
+
+BOX_WIDTH = 150  # width for box drawing
 
 
 class Options(Enum):
@@ -25,11 +32,8 @@ class Options(Enum):
 
 
 def args_parser():
-    print(f"""
-╔{'═' * 70}╗
-║ 🛠️  DevOps Tool Suite                                                    ║
-╚{'═' * 70}╝
-""")
+    # Print header
+    console.print(Panel("🛠️  DevOps Tool Suite", title_align="left", border_style="blue", width=BOX_WIDTH))
     
     import argparse
     parser = argparse.ArgumentParser()
@@ -39,177 +43,119 @@ def args_parser():
     main(which=args.which)
 
 
+def display_title(title):
+    console.print(Panel(title, box=box.DOUBLE_EDGE, title_align="left")) # Replace print with Panel
+
+def display_task_title(title):
+    console.print(Panel(title, box=box.ROUNDED, title_align="left")) # Replace print with Panel
+
+def display_task_status(status):
+    console.print(Panel(status, box=box.ROUNDED, title_align="left")) # Replace print with Panel
+
+def display_task_result(result):
+    console.print(Panel(result, box=box.ROUNDED, title_align="left")) # Replace print with Panel
+
+def display_task_error(error):
+    console.print(Panel(error, box=box.ROUNDED, border_style="red", title_align="left")) # Replace print with Panel
+
+def display_task_warning(warning):
+    console.print(Panel(warning, box=box.ROUNDED, border_style="yellow", title_align="left")) # Replace print with Panel
+
+def display_task_success(success):
+    console.print(Panel(success, box=box.ROUNDED, border_style="green", title_align="left")) # Replace print with Panel
+
+
 def main(which: Optional[str] = None):
     PROGRAM_PATH.delete(sure=True, verbose=False)
-    print(f"""
-╭{'─' * 70}╮
-│ 🚀 Initializing DevOps operation...                                      │
-╰{'─' * 70}╯
-""")
+    console.print(Panel("🚀 Initializing DevOps operation...", width=BOX_WIDTH, border_style="blue"))
     
     options = [op.value for op in Options]
     if which is None:
         try:
             choice_key = display_options(msg="", options=options, header="🛠️ DEVOPS", default=options[0])
         except KeyboardInterrupt:
-            print(f"""
-╔{'═' * 70}╗
-║ ❌ Operation cancelled by user                                           ║
-╚{'═' * 70}╝
-""")
+            console.print(Panel("❌ Operation cancelled by user", title_align="left", border_style="red", width=BOX_WIDTH))
             return
     else: choice_key = Options[which].value
 
-    print(f"""
-╔{'═' * 70}╗
-║ 🔧 SELECTED OPERATION                                                    ║
-╠{'═' * 70}╣
-║ {choice_key.center(68)} ║
-╚{'═' * 70}╝
-""")
+    console.print(Panel(f"🔧 SELECTED OPERATION\n{choice_key}", title_align="left", border_style="green", width=BOX_WIDTH))
 
     if choice_key == Options.update.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 🔄 Updating essential repositories...                                    │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("🔄 Updating essential repositories...", width=BOX_WIDTH, border_style="blue"))
         import machineconfig.scripts.python.devops_update_repos as helper
         program = helper.main()
 
     elif choice_key == Options.ve.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 🐍 Setting up virtual environment...                                     │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("🐍 Setting up virtual environment...", width=BOX_WIDTH, border_style="blue"))
         from machineconfig.utils.ve import get_ve_install_script
         program = get_ve_install_script()
 
     elif choice_key == Options.cli_install.value:
-        print(f"""
-╭{'─' * 70}╮
-│ ⚙️  Installing development applications...                                │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("⚙️  Installing development applications...", width=BOX_WIDTH, border_style="blue"))
         import machineconfig.scripts.python.devops_devapps_install as helper
         program = helper.main()
 
     elif choice_key == Options.sym_new.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 🔄 Creating new symlinks...                                              │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("🔄 Creating new symlinks...", width=BOX_WIDTH, border_style="blue"))
         import machineconfig.jobs.python.python_ve_symlink as helper
         program = helper.main()
 
     elif choice_key == Options.sym_path_shell.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 🔗 Setting up symlinks, PATH, and shell profile...                       │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("🔗 Setting up symlinks, PATH, and shell profile...", width=BOX_WIDTH, border_style="blue"))
         import machineconfig.profile.create as helper
         helper.main()
         program = "echo '✅ done with symlinks'"
 
     elif choice_key == Options.ssh_add_pubkey.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 🔑 Adding public SSH key to this machine...                              │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("🔑 Adding public SSH key to this machine...", width=BOX_WIDTH, border_style="blue"))
         import machineconfig.scripts.python.devops_add_ssh_key as helper
         program = helper.main()
 
     elif choice_key == Options.ssh_use_pair.value:
-        print(f"""
-╔{'═' * 70}╗
-║ ❌ ERROR: Not Implemented                                                ║
-║ SSH key pair connection feature is not yet implemented                   ║
-╚{'═' * 70}╝
-""")
+        console.print(Panel("❌ ERROR: Not Implemented\nSSH key pair connection feature is not yet implemented", title_align="left", border_style="red", width=BOX_WIDTH))
         raise NotImplementedError
 
     elif choice_key == Options.ssh_add_id.value:  # so that you can SSH directly withuot pointing to identity key.
-        print(f"""
-╭{'─' * 70}╮
-│ 🗝️  Adding SSH identity (private key) to this machine...                  │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("🗝️  Adding SSH identity (private key) to this machine...", width=BOX_WIDTH, border_style="blue"))
         import machineconfig.scripts.python.devops_add_identity as helper
         program = helper.main()
 
     elif choice_key == Options.ssh_setup.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 📡 Setting up SSH...                                                     │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("📡 Setting up SSH...", width=BOX_WIDTH, border_style="blue"))
         program_windows = """Invoke-WebRequest https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/openssh_all.ps1 | Invoke-Expression  # https://github.com/thisismygitrepo.keys"""
         program_linux = """curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/openssh_all.sh | sudo bash  # https://github.com/thisismygitrepo.keys"""
         program = program_linux if system() == "Linux" else program_windows
 
     elif choice_key == Options.ssh_setup_wsl.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 🐧 Setting up SSH for WSL...                                             │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("🐧 Setting up SSH for WSL...", width=BOX_WIDTH, border_style="blue"))
         program = """curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/openssh_wsl.sh | sudo bash"""
 
     elif choice_key == Options.backup.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 💾 Creating backup...                                                    │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("💾 Creating backup...", width=BOX_WIDTH, border_style="blue"))
         from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve as helper
         program = helper(direction="BACKUP")
         
     elif choice_key == Options.retreive.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 📥 Retrieving backup...                                                  │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("📥 Retrieving backup...", width=BOX_WIDTH, border_style="blue"))
         from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve as helper
         program = helper(direction="RETRIEVE")
 
     elif choice_key == Options.scheduler.value:
-        print(f"""
-╭{'─' * 70}╮
-│ ⏰ Setting up scheduler...                                               │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("⏰ Setting up scheduler...", width=BOX_WIDTH, border_style="blue"))
         from machineconfig.scripts.python.scheduler import main as helper
         program = helper()
 
     elif choice_key == Options.dot_files_sync.value:
-        print(f"""
-╭{'─' * 70}╮
-│ 🔗 Synchronizing dotfiles...                                             │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("🔗 Synchronizing dotfiles...", width=BOX_WIDTH, border_style="blue"))
         from machineconfig.scripts.python.cloud_repo_sync import main as helper, P
         program = helper(cloud=None, path=str(P.home() / "dotfiles"), pwd=None, action="ask")
 
     else: 
-        print(f"""
-╔{'═' * 70}╗
-║ ❌ ERROR: Invalid choice                                                 ║
-║ The selected operation is not implemented: {choice_key}                  
-╚{'═' * 70}╝
-""")
+        console.print(Panel("❌ ERROR: Invalid choice", title_align="left", border_style="red", width=BOX_WIDTH))
         raise ValueError(f"Unimplemented choice: {choice_key}")
         
     if program:
-        print(f"""
-╭{'─' * 70}╮
-│ 📜 Preparing shell script...                                             │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("📜 Preparing shell script...", width=BOX_WIDTH, border_style="blue"))
         write_shell_script_to_default_program_path(program=program, display=True, preserve_cwd=True, desc="🔧 Shell script prepared by Python.", execute=True if which is not None else False)
     else: 
         write_shell_script_to_default_program_path(program="echo '✨ Done.'", display=False, desc="🔧 Shell script prepared by Python.", preserve_cwd=True, execute=False)

machineconfig/scripts/python/devops_add_identity.py

@@ -4,125 +4,65 @@
 
 # from platform import system
 from crocodile.file_management import P
-from machineconfig.utils.utils_options import display_options
+from machineconfig.utils.options import display_options
+from rich.panel import Panel
+from rich.text import Text
+
+BOX_WIDTH = 150  # width for box drawing
 
 
 def main():
-    print(f"""
-╔{'═' * 70}╗
-║ 🔑 SSH IDENTITY MANAGEMENT                                               ║
-╚{'═' * 70}╝
-""")
-    
-    print(f"""
-╭{'─' * 70}╮
-│ 🔍 Searching for existing SSH keys...                                    │
-╰{'─' * 70}╯
-""")
-    
+    title = "🔑 SSH IDENTITY MANAGEMENT"
+    print(Panel(Text(title, justify="center"), expand=False))
+
+    print(Panel("🔍 Searching for existing SSH keys...", expand=False))
+
     private_keys = P.home().joinpath(".ssh").search("*.pub").apply(lambda x: x.with_name(x.stem)).filter(lambda x: x.exists())
-    
+
     if private_keys:
-        print(f"""
-╭{'─' * 70}╮
-│ ✅ Found {len(private_keys)} SSH private key(s)                                    │
-╰{'─' * 70}╯
-""")
+        print(Panel(f"✅ Found {len(private_keys)} SSH private key(s)", expand=False))
     else:
-        print(f"""
-╭{'─' * 70}╮
-│ ⚠️  No SSH private keys found                                             │
-╰{'─' * 70}╯
-""")
-        
+        print(Panel("⚠️  No SSH private keys found", expand=False))
+
     choice = display_options(msg="Path to private key to be used when ssh'ing: ", options=private_keys.apply(str).list + ["I have the path to the key file", "I want to paste the key itself"])
-    
+
     if choice == "I have the path to the key file":
-        print(f"""
-╭{'─' * 70}╮
-│ 📄 Please enter the path to your private key file                         │
-╰{'─' * 70}╯
-""")
+        print(Panel("📄 Please enter the path to your private key file", expand=False))
         path_to_key = P(input("📋 Input path here: ")).expanduser().absolute()
-        print(f"""
-╭{'─' * 70}╮
-│ 📂 Using key from custom path: {path_to_key}              │
-╰{'─' * 70}╯
-""")
-        
+        print(Panel(f"📂 Using key from custom path: {path_to_key}", expand=False))
+
     elif choice == "I want to paste the key itself":
-        print(f"""
-╭{'─' * 70}╮
-│ 📋 Please provide a filename and paste the private key content            │
-╰{'─' * 70}╯
-""")
+        print(Panel("📋 Please provide a filename and paste the private key content", expand=False))
         key_filename = input("📝 File name (default: my_pasted_key): ") or "my_pasted_key"
         path_to_key = P.home().joinpath(f".ssh/{key_filename}").write_text(input("🔑 Paste the private key here: "))
-        print(f"""
-╭{'─' * 70}╮
-│ 💾 Key saved to: {path_to_key}                           │
-╰{'─' * 70}╯
-""")
-        
-    elif isinstance(choice, str): 
+        print(Panel(f"💾 Key saved to: {path_to_key}", expand=False))
+
+    elif isinstance(choice, str):
         path_to_key = P(choice)
-        print(f"""
-╭{'─' * 70}╮
-│ 🔑 Using selected key: {path_to_key.name}                                 │
-╰{'─' * 70}╯
-""")
-        
-    else: 
-        print(f"""
-╔{'═' * 70}╗
-║ ❌ ERROR: Invalid choice                                                 ║
-║ The selected option is not supported: {choice}                           ║
-╚{'═' * 70}╝
-""")
+        print(Panel(f"🔑 Using selected key: {path_to_key.name}", expand=False))
+
+    else:
+        error_message = f"❌ ERROR: Invalid choice\nThe selected option is not supported: {choice}"
+        print(Panel(Text(error_message, justify="center"), expand=False, border_style="red"))
         raise NotImplementedError(f"Choice {choice} not supported")
-    
+
     txt = f"IdentityFile {path_to_key.collapseuser().as_posix()}"  # adds this id for all connections, no host specified.
     config_path = P.home().joinpath(".ssh/config")
-    
-    print(f"""
-╭{'─' * 70}╮
-│ 📝 Updating SSH configuration...                                          │
-╰{'─' * 70}╯
-""")
-    
-    if config_path.exists(): 
+
+    print(Panel("📝 Updating SSH configuration...", expand=False))
+
+    if config_path.exists():
         config_path.modify_text(txt_search=txt, txt_alt=txt, replace_line=True, notfound_append=True, prepend=True)  # note that Identity line must come on top of config file otherwise it won't work, hence `prepend=True`
-        print(f"""
-╭{'─' * 70}╮
-│ ✏️  Updated existing SSH config file                                       │
-╰{'─' * 70}╯
-""")
-    else: 
+        print(Panel("✏️  Updated existing SSH config file", expand=False))
+    else:
         config_path.write_text(txt)
-        print(f"""
-╭{'─' * 70}╮
-│ 📄 Created new SSH config file                                            │
-╰{'─' * 70}╯
-""")
-    
-    program = f"""echo '
-╔{'═' * 70}╗
-║ ✅ SSH IDENTITY CONFIGURATION COMPLETE                                   ║
-╠{'═' * 70}╣
-║ Identity added to SSH config file                                        ║
-║ Consider reloading the SSH config to apply changes                       ║
-╚{'═' * 70}╝
-'"""
-    
-    print(f"""
-╔{'═' * 70}╗
-║ 🎉 CONFIGURATION SUCCESSFUL                                              ║
-╠{'═' * 70}╣
-║ Identity added: {path_to_key.name}                                       
-║ Config file: {config_path}                                
-╚{'═' * 70}╝
-""")
-    
+        print(Panel("📄 Created new SSH config file", expand=False))
+
+    program = f"""echo '{Panel(Text("✅ SSH IDENTITY CONFIGURATION COMPLETE\nIdentity added to SSH config file\nConsider reloading the SSH config to apply changes", justify="center"), expand=False, border_style="green")}' """
+
+    success_message = f"🎉 CONFIGURATION SUCCESSFUL\nIdentity added: {path_to_key.name}\nConfig file: {config_path}"
+    print(Panel(Text(success_message, justify="center"), expand=False, border_style="green"))
+
     return program
 
 

machineconfig/scripts/python/devops_add_ssh_key.py

@@ -5,71 +5,38 @@
 from platform import system
 from machineconfig.utils.utils import LIBRARY_ROOT, display_options
 from crocodile.file_management import P
+from rich.console import Console
+from rich.panel import Panel
+from rich import box # Import box
+
+
+console = Console()
 
 
 def get_add_ssh_key_script(path_to_key: P):
-    print(f"""
-╔{'═' * 70}╗
-║ 🔑 SSH KEY CONFIGURATION                                                 ║
-╚{'═' * 70}╝
-""")
-    
-    if system() == "Linux": 
+    console.print(Panel("🔑 SSH KEY CONFIGURATION", title="[bold blue]SSH Setup[/bold blue]"))
+
+    if system() == "Linux":
         authorized_keys = P.home().joinpath(".ssh/authorized_keys")
-        print(f"""
-╭{'─' * 70}╮
-│ 🐧 Linux SSH configuration                                               │
-│ 📄 Authorized keys file: {authorized_keys}                      │
-╰{'─' * 70}╯
-""")
-    elif system() == "Windows": 
+        console.print(Panel(f"🐧 Linux SSH configuration\n📄 Authorized keys file: {authorized_keys}", title="[bold blue]System Info[/bold blue]"))
+    elif system() == "Windows":
         authorized_keys = P("C:/ProgramData/ssh/administrators_authorized_keys")
-        print(f"""
-╭{'─' * 70}╮
-│ 🪟 Windows SSH configuration                                             │
-│ 📄 Authorized keys file: {authorized_keys}                │
-╰{'─' * 70}╯
-""")
-    else: 
-        print(f"""
-╔{'═' * 70}╗
-║ ❌ ERROR: Unsupported operating system                                   ║
-║ Only Linux and Windows are supported                                     ║
-╚{'═' * 70}╝
-""")
+        console.print(Panel(f"🪟 Windows SSH configuration\n📄 Authorized keys file: {authorized_keys}", title="[bold blue]System Info[/bold blue]"))
+    else:
+        console.print(Panel("❌ ERROR: Unsupported operating system\nOnly Linux and Windows are supported", title="[bold red]Error[/bold red]"))
         raise NotImplementedError
 
     if authorized_keys.exists():
         split = "\n"
         keys_text = authorized_keys.read_text().split(split)
         key_count = len([k for k in keys_text if k.strip()])
-        
-        print(f"""
-╭{'─' * 70}╮
-│ 🔍 Current SSH authorization status                                      │
-│ ✅ Found {key_count} authorized key(s)                                        │
-╰{'─' * 70}╯
-""")
-        
+        console.print(Panel(f"🔍 Current SSH authorization status\n✅ Found {key_count} authorized key(s)", title="[bold blue]Status[/bold blue]"))
+
         if path_to_key.read_text() in authorized_keys.read_text():
-            print(f"""
-╔{'═' * 70}╗
-║ ⚠️  Key already authorized                                                ║
-╠{'═' * 70}╣
-║ Key: {path_to_key.name}
-║ Status: Already present in authorized_keys file
-║ No action required
-╚{'═' * 70}╝
-""")
+            console.print(Panel(f"⚠️  Key already authorized\nKey: {path_to_key.name}\nStatus: Already present in authorized_keys file\nNo action required", title="[bold yellow]Warning[/bold yellow]"))
             program = ""
         else:
-            print(f"""
-╭{'─' * 70}╮
-│ ➕ Adding new SSH key to authorized keys                                 │
-│ 🔑 Key file: {path_to_key.name}                                          │
-╰{'─' * 70}╯
-""")
-            
+            console.print(Panel(f"➕ Adding new SSH key to authorized keys\n🔑 Key file: {path_to_key.name}", title="[bold blue]Action[/bold blue]"))
             if system() == "Linux":
                 program = f"cat {path_to_key} >> ~/.ssh/authorized_keys"
             elif system() == "Windows":
@@ -78,34 +45,18 @@ def get_add_ssh_key_script(path_to_key: P):
                 place_holder = r'$sshfile = "$env:USERPROFILE\.ssh\pubkey.pub"'
                 assert place_holder in program, f"This section performs string manipulation on the script {program_path} to add the key to the authorized_keys file. The script has changed and the string {place_holder} is not found."
                 program = program.replace(place_holder, f'$sshfile = "{path_to_key}"')
-                print(f"""
-╭{'─' * 70}╮
-│ 🔧 Configured PowerShell script for Windows                              │
-│ 📝 Replaced placeholder with actual key path                             │
-╰{'─' * 70}╯
-""")
+                console.print(Panel("🔧 Configured PowerShell script for Windows\n📝 Replaced placeholder with actual key path", title="[bold blue]Configuration[/bold blue]"))
             else: raise NotImplementedError
     else:
-        print(f"""
-╭{'─' * 70}╮
-│ 📝 Creating new authorized_keys file                                     │
-│ 🔑 Using key: {path_to_key.name}                                         │
-╰{'─' * 70}╯
-""")
-        
+        console.print(Panel(f"📝 Creating new authorized_keys file\n🔑 Using key: {path_to_key.name}", title="[bold blue]Action[/bold blue]"))
         if system() == "Linux":
             program = f"cat {path_to_key} > ~/.ssh/authorized_keys"
         else:
             program_path = LIBRARY_ROOT.joinpath("setup_windows/openssh-server_add-sshkey.ps1")
             program = P(program_path).expanduser().read_text().replace('$sshfile=""', f'$sshfile="{path_to_key}"')
-            print(f"""
-╭{'─' * 70}╮
-│ 🔧 Configured PowerShell script for Windows                              │
-│ 📝 Set key path in script                                                │
-╰{'─' * 70}╯
-""")
+            console.print(Panel("🔧 Configured PowerShell script for Windows\n📝 Set key path in script", title="[bold blue]Configuration[/bold blue]"))
 
-    if system() == "Linux": 
+    if system() == "Linux":
         program += """
 
 sudo chmod 700 ~/.ssh
@@ -113,50 +64,21 @@ sudo chmod 644 ~/.ssh/authorized_keys
 sudo chmod 644 ~/.ssh/*.pub
 sudo service ssh --full-restart
 # from superuser.com/questions/215504/permissions-on-private-key-in-ssh-folder
-
 """
-        print(f"""
-╭{'─' * 70}╮
-│ 🔒 Setting proper SSH permissions and restarting service                 │
-╰{'─' * 70}╯
-""")
-        
-    print(f"""
-╔{'═' * 70}╗
-║ ✅ SSH KEY CONFIGURATION PREPARED                                        ║
-╚{'═' * 70}╝
-""")
-        
     return program
 
 
 def main():
-    print(f"""
-╔{'═' * 70}╗
-║ 🔐 SSH PUBLIC KEY AUTHORIZATION TOOL                                     ║
-╚{'═' * 70}╝
-""")
+    console.print(Panel("🔐 SSH PUBLIC KEY AUTHORIZATION TOOL", box=box.DOUBLE_EDGE, title_align="left"))
     
-    print(f"""
-╭{'─' * 70}╮
-│ 🔍 Searching for public keys...                                          │
-╰{'─' * 70}╯
-""")
+    console.print(Panel("🔍 Searching for public keys...", title="[bold blue]SSH Setup[/bold blue]", border_style="blue"))
     
     pub_keys = P.home().joinpath(".ssh").search("*.pub")
     
     if pub_keys:
-        print(f"""
-╭{'─' * 70}╮
-│ ✅ Found {len(pub_keys)} public key(s)                                           │
-╰{'─' * 70}╯
-""")
+        console.print(Panel(f"✅ Found {len(pub_keys)} public key(s)", title="[bold green]Status[/bold green]", border_style="green"))
     else:
-        print(f"""
-╭{'─' * 70}╮
-│ ⚠️  No public keys found                                                  │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("⚠️  No public keys found", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
     
     all_keys_option = f"all pub keys available ({len(pub_keys)})"
     i_have_path_option = "I have the path to the key file"
@@ -166,57 +88,28 @@ def main():
     assert isinstance(res, str), f"Got {res} of type {type(res)} instead of str."
     
     if res == all_keys_option:
-        print(f"""
-╭{'─' * 70}╮
-│ 🔄 Processing all {len(pub_keys)} public keys...                                  │
-╰{'─' * 70}╯
-""")
+        console.print(Panel(f"🔄 Processing all {len(pub_keys)} public keys...", title="[bold blue]Processing[/bold blue]", border_style="blue"))
         program = "\n\n\n".join(pub_keys.apply(get_add_ssh_key_script))
     
     elif res == i_have_path_option:
-        print(f"""
-╭{'─' * 70}╮
-│ 📂 Please provide the path to your public key                             │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("📂 Please provide the path to your public key", title="[bold blue]Input Required[/bold blue]", border_style="blue"))
         key_path = P(input("📋 Path: ")).expanduser().absolute()
-        print(f"""
-╭{'─' * 70}╮
-│ 📄 Using key from path: {key_path}                        │
-╰{'─' * 70}╯
-""")
+        console.print(Panel(f"📄 Using key from path: {key_path}", title="[bold blue]Info[/bold blue]", border_style="blue"))
         program = get_add_ssh_key_script(key_path)
     
     elif res == i_paste_option:
-        print(f"""
-╭{'─' * 70}╮
-│ 📋 Please provide a filename and paste the public key content             │
-╰{'─' * 70}╯
-""")
+        console.print(Panel("📋 Please provide a filename and paste the public key content", title="[bold blue]Input Required[/bold blue]", border_style="blue"))
         key_filename = input("📝 File name (default: my_pasted_key.pub): ") or "my_pasted_key.pub"
         key_path = P.home().joinpath(f".ssh/{key_filename}")
         key_path.write_text(input("🔑 Paste the public key here: "))
-        print(f"""
-╭{'─' * 70}╮
-│ 💾 Key saved to: {key_path}                           │
-╰{'─' * 70}╯
-""")
+        console.print(Panel(f"💾 Key saved to: {key_path}", title="[bold green]Success[/bold green]", border_style="green"))
         program = get_add_ssh_key_script(key_path)
     
     else:
-        print(f"""
-╭{'─' * 70}╮
-│ 🔑 Using selected key: {P(res).name}                                     │
-╰{'─' * 70}╯
-""")
+        console.print(Panel(f"🔑 Using selected key: {P(res).name}", title="[bold blue]Info[/bold blue]", border_style="blue"))
         program = get_add_ssh_key_script(P(res))
     
-    print(f"""
-╔{'═' * 70}╗
-║ 🚀 SSH KEY AUTHORIZATION READY                                           ║
-║ Run the generated script to apply changes                                ║
-╚{'═' * 70}╝
-""")
+    console.print(Panel("🚀 SSH KEY AUTHORIZATION READY\nRun the generated script to apply changes", box=box.DOUBLE_EDGE, title_align="left"))
     
     return program