paramtui 0.1.0__py3-none-any.whl

manager/__init__.py

@@ -0,0 +1,10 @@
+"""ParamTUI - SSH Manager & HPC Console.
+
+A modular terminal user interface for managing HPC clusters.
+"""
+
+from manager.connection import SSHConnection
+from manager.ui.menus import main_menu, connection_menu
+
+__all__ = ['SSHConnection', 'main_menu', 'connection_menu']
+__version__ = '1.0.0'

manager/commands/__init__.py

@@ -0,0 +1,12 @@
+"""Commands subpackage - Backend operations for SSH management."""
+
+from manager.commands.slurm import *
+from manager.commands.conda import *
+from manager.commands.files import *
+from manager.commands.modules import *
+from manager.commands.resources import *
+from manager.commands.job_templates import *
+from manager.commands.logs import *
+from manager.commands.settings import *
+from manager.commands.help import *
+from manager.commands.tunnel import *

manager/commands/conda.py

@@ -0,0 +1,61 @@
+"""Conda environment management commands."""
+
+from rich.console import Console
+
+console = Console()
+
+
+def conda_list_envs(ssh_conn):
+    """List all conda environments."""
+    output = ssh_conn.execute_command(" conda env list")
+    if output:
+        console.print("[bold green]Conda Environments:[/bold green]")
+        console.print(output)
+
+
+def conda_activate_env(ssh_conn, env_name):
+    """Activate a conda environment."""
+    console.print(f"[bold yellow]Activating environment '{env_name}'...[/bold yellow]")
+    output = ssh_conn.execute_command(f"source conda activate {env_name}")
+    if output and ("error" in output.lower() or "not found" in output.lower()):
+        console.print(f"[bold red]Failed to activate environment:[/bold red] {output}")
+    else:
+        console.print("[bold green]Environment activated![/bold green]")
+
+
+def conda_create_env(ssh_conn, env_name, python_version=None):
+    """Create a new conda environment."""
+    if python_version:
+        cmd = f"conda create -n {env_name} python={python_version} -y"
+    else:
+        cmd = f"conda create -n {env_name} -y"
+    
+    console.print(f"[bold yellow]Creating environment '{env_name}'...[/bold yellow]")
+    output = ssh_conn.execute_command(cmd)
+    if output:
+        console.print("[bold green]Environment created successfully![/bold green]")
+
+
+def conda_remove_env(ssh_conn, env_name):
+    """Remove a conda environment."""
+    console.print(f"[bold yellow]Removing environment '{env_name}'...[/bold yellow]")
+    output = ssh_conn.execute_command(f"conda env remove -n {env_name} -y")
+    console.print("[bold green]Environment removed![/bold green]")
+
+
+def conda_install_package(ssh_conn, env_name, package):
+    """Install a package in a conda environment."""
+    console.print(f"[bold yellow]Installing {package} in '{env_name}'...[/bold yellow]")
+    output = ssh_conn.execute_command(f"conda install -n {env_name} {package} -y")
+    if output:
+        console.print("[bold green]Package installed![/bold green]")
+        
+def conda_list_package(ssh_conn, env_name):
+    """Install a package in a conda environment."""
+    console.print(f"[bold yellow]Packages installed in '{env_name}'...[/bold yellow]")
+    if env_name == 'base':
+        output = ssh_conn.execute_command(f"source ~/.bashrc && conda list -n base")
+    else:
+        output = ssh_conn.execute_command(f"source ~/.bashrc && conda list -n {env_name}")
+    if output:
+        console.print({output})

manager/commands/files.py

@@ -0,0 +1,186 @@
+"""File management commands."""
+
+import subprocess
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich import box
+
+console = Console()
+
+
+def file_browse_directory(ssh_conn, path="~"):
+    """Browse a directory and show files with details."""
+    cmd = f"ls -la {path}"
+    output = ssh_conn.execute_command(cmd)
+    if output:
+        table = Table(title=f"📁 Directory: {path}", box=box.ROUNDED)
+        table.add_column("Permissions", style="cyan")
+        table.add_column("Owner", style="green")
+        table.add_column("Group", style="green")
+        table.add_column("Size", style="yellow", justify="right")
+        table.add_column("Modified", style="magenta")
+        table.add_column("Name", style="bold white")
+        
+        lines = output.strip().split('\n')[1:]
+        for line in lines:
+            parts = line.split(None, 8)
+            if len(parts) >= 9:
+                perms = parts[0]
+                owner = parts[2]
+                group = parts[3]
+                size = parts[4]
+                date_str = f"{parts[5]} {parts[6]} {parts[7]}"
+                name = parts[8]
+                icon = "📁" if perms.startswith('d') else "📄"
+                table.add_row(perms, owner, group, size, date_str, f"{icon} {name}")
+        
+        console.print(table)
+        return True
+    return False
+
+
+def file_get_home_path(ssh_conn):
+    """Get user's home directory."""
+    return ssh_conn.execute_command("echo $HOME").strip()
+
+
+def file_get_scratch_path(ssh_conn):
+    """Get user's scratch directory."""
+    output = ssh_conn.execute_command("echo ~/scratch")
+    return output.strip()
+
+
+def file_upload(ssh_conn, local_path, remote_path):
+    """Upload a file to the remote server."""
+    try:
+        cmd = f"scp -P {ssh_conn.port} -o ControlPath={ssh_conn.control_path} {local_path} {ssh_conn.user}@{ssh_conn.host}:{remote_path}"
+        console.print(f"[bold yellow]Uploading {local_path} to {remote_path}...[/bold yellow]")
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        if result.returncode == 0:
+            console.print("[bold green]✓ Upload successful![/bold green]")
+            return True
+        else:
+            console.print(f"[bold red]✗ Upload failed: {result.stderr}[/bold red]")
+            return False
+    except Exception as e:
+        console.print(f"[bold red]✗ Upload error: {str(e)}[/bold red]")
+        return False
+
+
+def file_download(ssh_conn, remote_path, local_path):
+    """Download a file from the remote server."""
+    try:
+        cmd = f"scp -P {ssh_conn.port} -o ControlPath={ssh_conn.control_path} {ssh_conn.user}@{ssh_conn.host}:{remote_path} {local_path}"
+        console.print(f"[bold yellow]Downloading {remote_path} to {local_path}...[/bold yellow]")
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        if result.returncode == 0:
+            console.print("[bold green]✓ Download successful![/bold green]")
+            return True
+        else:
+            console.print(f"[bold red]✗ Download failed: {result.stderr}[/bold red]")
+            return False
+    except Exception as e:
+        console.print(f"[bold red]✗ Download error: {str(e)}[/bold red]")
+        return False
+
+def file_edit(ssh_conn, path, filename):
+    """Edit file."""
+    console.print(f"[bold yellow]Starting nano editor...[/bold yellow]")
+    
+    cmd = f"nano {path}/{filename}"
+    try:
+        subprocess.run(
+            f"ssh -S {ssh_conn.control_path} -t -p {ssh_conn.port} {ssh_conn.user}@{ssh_conn.host} '{cmd}'",
+            shell=True
+        )
+    except Exception as e:
+        console.print(f"[bold red]Session error: {str(e)}[/bold red]")
+    
+    
+def file_create_directory(ssh_conn, path):
+    """Create a new directory."""
+    output = ssh_conn.execute_command(f"mkdir -p {path} && echo 'SUCCESS'")
+    if output and 'SUCCESS' in output:
+        console.print(f"[bold green]✓ Directory created: {path}[/bold green]")
+        return True
+    console.print(f"[bold red]✗ Failed to create directory[/bold red]")
+    return False
+
+
+def file_delete(ssh_conn, path, is_directory=False):
+    """Delete a file or directory."""
+    cmd = f"rm -rf {path}" if is_directory else f"rm {path}"
+    output = ssh_conn.execute_command(f"{cmd} && echo 'SUCCESS'")
+    if output and 'SUCCESS' in output:
+        console.print(f"[bold green]✓ Deleted: {path}[/bold green]")
+        return True
+    console.print(f"[bold red]✗ Failed to delete[/bold red]")
+    return False
+
+
+def file_rename(ssh_conn, old_path, new_path):
+    """Rename/move a file or directory."""
+    output = ssh_conn.execute_command(f"mv {old_path} {new_path} && echo 'SUCCESS'")
+    if output and 'SUCCESS' in output:
+        console.print(f"[bold green]✓ Renamed: {old_path} → {new_path}[/bold green]")
+        return True
+    console.print(f"[bold red]✗ Failed to rename[/bold red]")
+    return False
+
+
+def file_view_content(ssh_conn, path, lines=50):
+    """View file content (for text files)."""
+    output = ssh_conn.execute_command(f"head -n {lines} {path}")
+    if output:
+        ext = path.split('.')[-1] if '.' in path else 'txt'
+        syntax = Syntax(output, ext, theme="monokai", line_numbers=True)
+        console.print(Panel(syntax, title=f"📄 {path}", border_style="green"))
+        return True
+    return False
+
+def file_search(ssh_conn, path, pattern, depth):
+    """Search for files by name pattern."""
+    console.print(f"[bold cyan]Searching for '{pattern}' in {path}...[/bold cyan]\n")
+    cmd1 = f'find {path} -maxdepth 1 -name "*{pattern}*" | head -50'
+    output = ssh_conn.execute_command(cmd1)
+    
+    if output and output.strip() and not depth:
+        console.print("[bold green]Files found in depth:[/bold green]")
+        console.print(output)
+        return True
+    else:
+        cmd2 = f'find {path} -name "*{pattern}*" | head -50'
+        output = ssh_conn.execute_command(cmd2)
+        
+        if output and output.strip():
+            console.print("[bold green]Files found (recursive search):[/bold green]")
+            console.print(output)
+            return True
+        else:
+            console.print("[yellow]No files found matching the pattern.[/yellow]")
+            return False
+
+def file_disk_quota(ssh_conn, path="~"):
+    """Get disk usage for a directory."""
+    output = ssh_conn.execute_command(f"du -h {path} | sort -hr | head -20")
+    if output:
+        table = Table(title=f"💾 Disk Usage: {path}", box=box.ROUNDED)
+        table.add_column("Size", style="yellow", justify="right")
+        table.add_column("Path", style="cyan")
+        
+        for line in output.strip().split('\n'):
+            if line:
+                parts = line.split('\t', 1)
+                if len(parts) == 2:
+                    table.add_row(parts[0], parts[1])
+        
+        console.print(table)
+        
+        quota_output = ssh_conn.execute_command("lfs quota -h ~/")
+        if quota_output:
+            console.print("\n[bold cyan]Quota Information:[/bold cyan]")
+            console.print(quota_output)
+        return True
+    return False

manager/commands/help.py

@@ -0,0 +1,165 @@
+"""Help and documentation commands."""
+
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+def help_slurm_cheatsheet():
+    """Display SLURM cheat sheet."""
+    cheatsheet = """
+  [bold cyan]📋 SLURM Cheat Sheet[/bold cyan]
+
+  [bold green]Quick sbatch script example:[/bold green]
+    #!/bin/bash
+    #SBATCH --job-name=training
+    #SBATCH --output=out.%j.log
+    #SBATCH --error=err.%j.log
+    #SBATCH --nodes=1
+    #SBATCH --ntasks=1
+    #SBATCH --cpus-per-task=8
+    #SBATCH --gres=gpu:1
+    #SBATCH --mem=32G
+    #SBATCH --time=02:00:00
+    #SBATCH --partition=gpu
+    module purge
+    module load anaconda/3
+    source activate myenv
+    srun python train.py --epochs 10
+
+  [bold green]Common sbatch flags (CLI):[/bold green]
+    sbatch --job-name=name --output=out.%j.log --partition=gpu --gres=gpu:1 script.sh
+    sbatch --array=1-10%3 array_script.sh      Run job arrays (limit concurrent with %)
+    sbatch --dependency=afterok:<jobid> script.sh   Chain jobs on success
+    sbatch --wrap="python -u quick_task.py"     Submit single command
+
+  [bold green]srun examples:[/bold green]
+    srun --pty --nodes=1 --ntasks=1 --cpus-per-task=4 bash    Interactive shell in allocation
+    srun -n 16 --mpi=pmi2 ./mpi_program                      Run MPI across 16 tasks
+    srun --gres=gpu:2 python train.py                        Launch task within job
+
+  [bold green]salloc (interactive allocation):[/bold green]
+    salloc --nodes=1 --gres=gpu:1 --time=01:00:00
+    # then inside allocation:
+    srun --pty bash
+    # or run Jupyter:
+    srun --mem=16G --cpus-per-task=4 jupyter lab --no-browser --port=8888
+
+  [bold green]Monitoring & info:[/bold green]
+    squeue -u $USER                        Show current jobs
+    squeue -j <jobid>                      Show specific job
+    squeue -o "%.18i %.9P %.8j %.8u %.2t %.10M %.6D %R"  Custom output format
+    sacct -j <jobid> --format=JobID,JobName,State,ExitCode,Elapsed         Accounting
+    seff <jobid>                           Efficiency (CPU/GPU/memory usage)
+    sinfo -s                                Summary of partitions
+    sinfo -N -l                             Detailed node listing
+    scontrol show job <jobid>               Full job details
+    scontrol show node <nodename>           Node diagnostics
+
+  [bold green]Job control:[/bold green]
+    scancel <jobid>                         Cancel job
+    scancel -u $USER                        Cancel all your jobs
+    scontrol update JobId=<jobid> TimeLimit=HH:MM:SS  Modify job (if permitted)
+
+  [bold green]Resource & environment tips:[/bold green]
+    --gres=gpu:V100:1 or --gres=gpu:1        Request specific GPU type if supported
+    --mem=32G                                Memory per node; use --mem-per-cpu for per-core
+    --cpus-per-task=8                        Useful for multithreaded tasks
+    export OMP_NUM_THREADS=8                 Match threads to cpus-per-task
+    echo $SLURM_JOB_ID                       Job ID accessible in scripts
+    echo $SLURM_NTASKS $SLURM_NNODES         Common SLURM env vars
+
+  [bold green]Job arrays & parametrization:[/bold green]
+    #SBATCH --array=0-9
+    TASK_ID=${SLURM_ARRAY_TASK_ID}
+    INPUT=file_${TASK_ID}.txt
+    # run array with per-task inputs or offsets
+
+  [bold green]Checkpointing & restarts (pattern):[/bold green]
+    # write periodic checkpoints to $SCRATCH or $TMPDIR
+    # save model state with step number or epoch
+    # on restart, read latest checkpoint and submit continuation via --dependency
+
+  [bold green]Interactive GPU debugging:[/bold green]
+    srun --pty --gres=gpu:1 --mem=16G --cpus-per-task=4 --time=00:30:00 bash
+    # run nvidia-smi to inspect GPU allocation and processes
+
+  [bold green]Data transfer & staging tips:[/bold green]
+    rsync -avP local_dir user@host:/scratch/$USER/project/   Efficient sync of datasets
+    scp file user@host:/scratch/$USER/                       Simple copy for small files
+    Use $SCRATCH or $TMPDIR on compute nodes for I/O-heavy operations, then rsync back
+
+  [bold green]Troubleshooting commands:[/bold green]
+    scontrol show job <jobid>         Inspect job reasons for PENDING
+    scontrol show partition <part>    See partition limits and nodes
+    journalctl -u slurmctld          (admin-only) cluster controller logs
+    module avail | grep -i <name>     Find available modules
+
+  [bold green]Useful patterns:[/bold green]
+    # Submit and track:
+    jid=$(sbatch --parsable train.sh)
+    squeue -j $jid
+    # Submit dependent job:
+    sbatch --dependency=afterok:$jid evaluate.sh
+
+  [bold green]Shortcuts & sensible defaults:[/bold green]
+    --time=01:00:00  small debug
+    --time=24:00:00  typical training epoch
+    --partition=debug  short-queue for quick tests (if available)
+
+  [bold yellow]Remember:[/bold yellow] Check your cluster's documentation for partition names, available GPUs, and site-specific sbatch directives.
+  """
+    console.print(Panel(cheatsheet, title="📚 SLURM Quick Reference", border_style="cyan"))
+
+
+def help_common_errors():
+    """Display common errors and fixes."""
+    errors = """
+[bold cyan]🔧 Common Errors & Fixes[/bold cyan]
+
+[bold red]Job stuck in PENDING with (Priority):[/bold red]
+  → Wait for higher priority jobs to complete
+  → Check partition limits: scontrol show partition
+
+[bold red]Job stuck in PENDING with (Resources):[/bold red]
+  → Requested resources unavailable
+  → Try: reduce nodes/memory/time or different partition
+
+[bold red]CUDA out of memory:[/bold red]
+  → Reduce batch size
+  → Use gradient accumulation
+  → Request more GPU memory
+
+[bold red]Module not found:[/bold red]
+  → Run: module avail | grep -i <name>
+  → Check for typos in module name
+
+[bold red]Permission denied:[/bold red]
+  → Check file permissions: ls -la
+  → Use chmod to fix: chmod +x script.sh
+
+[bold red]Connection timeout:[/bold red]
+  → Check network connectivity
+  → Verify SSH port and hostname
+  → Try reconnecting
+"""
+    console.print(Panel(errors, title="🔧 Troubleshooting Guide", border_style="yellow"))
+
+
+def help_about():
+    """Display about information."""
+    about_text = """
+[bold cyan]PARAM SSH Manager & HPC Console[/bold cyan]
+
+A modern terminal user interface for managing HPC clusters.
+
+[bold green]Features:[/bold green]
+  • SSH connection management with ControlMaster
+  • SLURM job submission and monitoring
+  • File management (upload/download/browse)
+  • Conda environment management
+
+[bold yellow]Version:[/bold yellow] 1.0.0
+[bold yellow]Author:[/bold yellow] [link=https://github.com/ayush1512]Ayush Saxena[/link]
+"""
+    console.print(Panel(about_text, title="📖 About", border_style="cyan"))

manager/commands/job_templates.py

@@ -0,0 +1,132 @@
+"""Job template management commands."""
+
+import subprocess
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import box
+
+from manager.templates import JOB_TEMPLATES
+
+console = Console()
+
+
+def template_list():
+    """List available job templates."""
+    table = Table(title="📝 Available Job Templates", box=box.ROUNDED)
+    table.add_column("Template", style="cyan")
+    table.add_column("Description", style="green")
+    
+    templates_info = {
+        "python": "Basic Python script execution",
+        "mpi": "MPI parallel job",
+        "cuda": "CUDA GPU job",
+        "pytorch": "PyTorch deep learning job",
+        "tensorflow": "TensorFlow deep learning job",
+        "jupyter": "Jupyter Notebook/Lab session",
+    }
+    
+    for name, desc in templates_info.items():
+        table.add_row(name, desc)
+    
+    console.print(table)
+    return list(templates_info.keys())
+
+
+def template_generate(template_name, **kwargs):
+    """Generate a job script from template."""
+    if template_name not in JOB_TEMPLATES:
+        console.print(f"[bold red]Template '{template_name}' not found![/bold red]")
+        return None
+    
+    try:
+        script = JOB_TEMPLATES[template_name].format(**kwargs)
+        return script
+    except KeyError as e:
+        console.print(f"[bold red]Missing parameter: {e}[/bold red]")
+        return None
+
+
+def template_save(ssh_conn, script_content, filename):
+    """Save a job script to remote server."""
+    cmd = f"cat > {filename} << 'SCRIPT_EOF'\n{script_content}\nSCRIPT_EOF"
+    ssh_conn.execute_command(cmd)
+    console.print(f"[bold green]✓ Script saved to: {filename}[/bold green]")
+    return filename
+
+
+def template_submit(ssh_conn, script_path):
+    """Submit a job script."""
+    output = ssh_conn.execute_command(f"sbatch {script_path}")
+    if output:
+        console.print(f"[bold green]✓ Job submitted![/bold green]")
+        console.print(output)
+        return True
+    return False
+
+
+def interactive_start_jupyter(ssh_conn, jupyter_type="notebook", conda_env="base", num_gpus=0, port=8888):
+    """Start Jupyter Notebook/Lab via SLURM."""
+    template = JOB_TEMPLATES["jupyter"]
+    script = template.format(
+        job_name="jupyter",
+        conda_env=conda_env,
+        num_gpus=num_gpus,
+        port=port,
+        jupyter_type=jupyter_type,
+        user=ssh_conn.user,
+        host=ssh_conn.host,
+        ssh_port=ssh_conn.port
+    )
+    
+    script_path = f"~/.jupyter_job_{port}.sh"
+    ssh_conn.execute_command(f"cat > {script_path} << 'EOF'\n{script}\nEOF")
+    
+    output = ssh_conn.execute_command(f"sbatch {script_path}")
+    if output:
+        console.print(f"[bold green]✓ Jupyter {jupyter_type} job submitted![/bold green]")
+        console.print(output)
+        console.print(f"\n[bold cyan]Once the job starts, create an SSH tunnel:[/bold cyan]")
+        console.print(f"[yellow]ssh -L {port}:<node>:{port} {ssh_conn.user}@{ssh_conn.host} -p {ssh_conn.port}[/yellow]")
+        console.print(f"\n[bold cyan]Then open in browser:[/bold cyan] http://localhost:{port}")
+        return True
+    return False
+
+
+def interactive_gpu_session(ssh_conn, num_gpus=1, time="02:00:00", mem="16G"):
+    """Start an interactive GPU session."""
+    console.print(f"[bold yellow]Starting interactive GPU session ({num_gpus} GPU(s))...[/bold yellow]")
+    console.print("[dim]This will open an interactive shell. Type 'exit' to end the session.[/dim]\n")
+    
+    cmd = f"srun --gres=gpu:{num_gpus} --time={time} --mem={mem} --pty bash"
+    try:
+        subprocess.run(
+            f"ssh -S {ssh_conn.control_path} -t -p {ssh_conn.port} {ssh_conn.user}@{ssh_conn.host} '{cmd}'",
+            shell=True
+        )
+    except Exception as e:
+        console.print(f"[bold red]Session error: {str(e)}[/bold red]")
+
+def interactive_cpu_session(ssh_conn, num_cpus=1, time="02:00:00", core="40"):
+    """Start an interactive GPU session."""
+    console.print(f"[bold yellow]Starting interactive CPU session ({num_cpus} CPU(s))...[/bold yellow]")
+    console.print("[dim]This will open an interactive shell. Type 'exit' to end the session.[/dim]\n")
+    
+    cmd = f"srun --partition=cpu -N {num_cpus} --time={time} -c {core} --pty bash"
+    try:
+        subprocess.run(
+            f"ssh -S {ssh_conn.control_path} -t -p {ssh_conn.port} {ssh_conn.user}@{ssh_conn.host} '{cmd}'",
+            shell=True
+        )
+    except Exception as e:
+        console.print(f"[bold red]Session error: {str(e)}[/bold red]")
+
+def interactive_list_notebooks(ssh_conn):
+    """List running Jupyter jobs."""
+    output = ssh_conn.execute_command("squeue -u $USER -n jupyter_* -o '%.18i %.15j %.8T %.10M %.R' 2>/dev/null")
+    if output and len(output.strip().split('\n')) > 1:
+        console.print("[bold green]📓 Running Jupyter Sessions:[/bold green]")
+        console.print(output)
+        return True
+    console.print("[yellow]No active Jupyter sessions found.[/yellow]")
+    return False

manager/commands/logs.py

@@ -0,0 +1,42 @@
+"""Log management commands."""
+
+from datetime import datetime, timedelta
+from rich.console import Console
+from rich.panel import Panel
+
+from manager.commands.files import file_download
+
+console = Console()
+
+
+def logs_get_session_history(ssh_conn, lines=50):
+    """Get SSH session history."""
+    output = ssh_conn.execute_command(f"last -n {lines} $USER || last -n {lines}")
+    if output:
+        console.print(Panel(output, title="📋 Session History", border_style="cyan"))
+        return True
+    return False
+
+
+def logs_get_job_submission_history(ssh_conn, days=7):
+    """Get job submission history."""
+    start_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
+    output = ssh_conn.execute_command(f"sacct -u $USER -S {start_date} -o JobID,JobName,Submit,Start,End,State | head -50")
+    if output:
+        console.print(Panel(output, title=f"📝 Job Submission History (Last {days} days)", border_style="green"))
+        return True
+    return False
+
+
+def logs_get_error_logs(ssh_conn, pattern="*.err"):
+    """Find and list recent error logs."""
+    output = ssh_conn.execute_command(f"find ~ -name '{pattern}' -mtime -7 -type f  | head -20")
+    if output:
+        console.print("[bold cyan]📋 Recent Error Logs:[/bold cyan]")
+        for log in output.strip().split('\n'):
+            if log:
+                console.print(f"  📄 {log}")
+        return output.strip().split('\n')
+    console.print("[yellow]No recent error logs found.[/yellow]")
+    return []
+