toasts and admin

Author: solusops

README.md

@@ -154,6 +154,14 @@ REST API endpoints (web mode):
 - `GET /` - Web dashboard
 - `GET /api/status` - Current GPU metrics
 - `GET /api/history` - Historical data
+
+### Admin mode
+
+If you need the web dashboard to perform privileged actions (terminate processes, restart services), start the server with the `--admin` flag. This signals the application that it should enable administrative actions and the dashboard will show admin controls.
+
+```powershell
+python health_monitor.py web --port 8890 --admin
+```
 - `POST /api/benchmark/start` - Start benchmark
 - `GET /api/benchmark/status` - Benchmark progress
 - `POST /api/benchmark/stop` - Stop benchmark

health_monitor.py

@@ -255,6 +255,74 @@ async def run_cli_monitor(config: dict):
 
 def _run_app(config_path, port, nodes, once, web_mode=False, cli_mode=False):
     """Helper to run main application logic."""
+    # If the user requested admin mode via --admin in argv, and the process is not elevated,
+    # attempt to relaunch elevated (UAC on Windows, sudo on POSIX). This check is done here
+    # to cover both top-level and subcommand usages (e.g. `health_monitor.py web --admin`).
+    try:
+        import sys, platform, os
+        def _is_elevated():
+            try:
+                if platform.system() == 'Windows':
+                    import ctypes
+                    return bool(ctypes.windll.shell32.IsUserAnAdmin())
+                else:
+                    return (os.geteuid() == 0)
+            except Exception:
+                return False
+
+        if '--admin' in (sys.argv[1:] if len(sys.argv) > 1 else []) and not _is_elevated():
+            # Attempt relaunch elevated. Use ShellExecuteW on Windows, fallback to PowerShell;
+            # on POSIX try sudo exec.
+            try:
+                if platform.system() == 'Windows':
+                    try:
+                        import ctypes
+                        params = '"' + os.path.abspath(sys.argv[0]) + '"'
+                        other_args = [a for a in sys.argv[1:]]
+                        if other_args:
+                            params += ' ' + ' '.join(str(a) for a in other_args)
+                        ret = ctypes.windll.shell32.ShellExecuteW(None, 'runas', sys.executable, params, None, 1)
+                        try:
+                            ok = int(ret) > 32
+                        except Exception:
+                            ok = False
+                        if ok:
+                            print('Relaunching elevated, exiting original process')
+                            try: os._exit(0)
+                            except Exception: pass
+                    except Exception:
+                        pass
+
+                    # PowerShell fallback
+                    try:
+                        import subprocess
+                        def _ps_quote(s):
+                            return "'" + str(s).replace("'", "''") + "'"
+                        ps_args = [os.path.abspath(sys.argv[0])] + list(sys.argv[1:])
+                        arglist_literal = ','.join(_ps_quote(a) for a in ps_args)
+                        ps_cmd = [
+                            'powershell', '-NoProfile', '-NonInteractive', '-Command',
+                            f"Start-Process -FilePath '{sys.executable}' -ArgumentList {arglist_literal} -Verb RunAs"
+                        ]
+                        proc = subprocess.run(ps_cmd, capture_output=True, text=True, timeout=15)
+                        if proc.returncode == 0:
+                            try: os._exit(0)
+                            except Exception: pass
+                    except Exception:
+                        pass
+
+                else:
+                    # POSIX: try exec via sudo
+                    try:
+                        print('Attempting to relaunch with sudo...')
+                        os.execvp('sudo', ['sudo', sys.executable, os.path.abspath(sys.argv[0])] + list(sys.argv[1:]))
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+    except Exception:
+        pass
+
     console.print(BANNER, style="bold cyan")
 
     # Load configuration
@@ -299,9 +367,91 @@ async def main():
 @click.option('--config', '-c', type=click.Path(), help='Configuration file path.')
 @click.option('--port', '-p', type=int, help='Web server port (default: 8090).')
 @click.option('--update', is_flag=True, help='Check for and install updates.')
+@click.option('--admin', is_flag=True, help='Start in administrative mode (enables privileged dashboard actions).')
 @click.pass_context
-def cli(ctx, config, port, update):
+def cli(ctx, config, port, update, admin):
     """Cluster Health Monitor: Real-time GPU and system health monitoring."""
+    # If the user requested admin mode, attempt to relaunch this process elevated
+    # on platforms that support elevation (Windows -> UAC, POSIX -> sudo).
+    def _is_elevated():
+        try:
+            import platform
+            if platform.system() == 'Windows':
+                import ctypes
+                return bool(ctypes.windll.shell32.IsUserAnAdmin())
+            else:
+                import os
+                return (os.geteuid() == 0)
+        except Exception:
+            return False
+
+    def _relaunch_elevated():
+        try:
+            import platform, sys, os, subprocess, shlex
+            script = os.path.abspath(sys.argv[0])
+            args = sys.argv[1:]
+            # Ensure --admin present
+            if '--admin' not in args:
+                args = args + ['--admin']
+
+            if platform.system() == 'Windows':
+                try:
+                    import ctypes
+                    params = '"' + script + '"'
+                    if args:
+                        params += ' ' + ' '.join(str(a) for a in args)
+                    ret = ctypes.windll.shell32.ShellExecuteW(None, 'runas', sys.executable, params, None, 1)
+                    try:
+                        ok = int(ret) > 32
+                    except Exception:
+                        ok = False
+                    if ok:
+                        # launched elevated; exit current process
+                        print('Relaunching elevated, exiting original process')
+                        try: os._exit(0)
+                        except SystemExit: raise
+                        except Exception: pass
+                    else:
+                        print('ShellExecuteW failed to elevate (ret=' + str(ret) + ')')
+                except Exception as e:
+                    print('Windows elevation exception:', e)
+
+                # PowerShell fallback
+                try:
+                    def _ps_quote(s):
+                        return "'" + str(s).replace("'", "''") + "'"
+                    ps_args = [script] + list(args)
+                    arglist_literal = ','.join(_ps_quote(a) for a in ps_args)
+                    ps_cmd = [
+                        'powershell', '-NoProfile', '-NonInteractive', '-Command',
+                        f"Start-Process -FilePath '{sys.executable}' -ArgumentList {arglist_literal} -Verb RunAs"
+                    ]
+                    proc = subprocess.run(ps_cmd, capture_output=True, text=True, timeout=15)
+                    if proc.returncode == 0:
+                        try: os._exit(0)
+                        except Exception: pass
+                    else:
+                        print('PowerShell elevation failed:', proc.returncode, proc.stderr)
+                except Exception as e:
+                    print('PowerShell fallback exception:', e)
+
+            else:
+                # POSIX: try exec via sudo
+                try:
+                    print('Attempting to relaunch with sudo...')
+                    os.execvp('sudo', ['sudo', sys.executable, script] + list(args))
+                except Exception as e:
+                    print('sudo relaunch failed:', e)
+
+        except Exception as e:
+            print('Relaunch elevation error:', e)
+
+    # If admin requested and not already elevated, attempt to relaunch elevated
+    try:
+        if admin and not _is_elevated():
+            _relaunch_elevated()
+    except Exception:
+        pass
     if update:
         from monitor.utils import check_for_updates, perform_update
         console.print("\n[cyan]Checking for updates...[/cyan]")
@@ -328,15 +478,30 @@ def cli(ctx, config, port, update):
                 console.print("[red]Update failed. Try again later.[/red]")
         return
 
-    ctx.obj = {'config_path': config}
+    ctx.obj = {'config_path': config, 'admin': admin}
     if ctx.invoked_subcommand is None:
+        # If admin flag set, append to sys.argv so server.detect features and app.state see it
+        if admin and '--admin' not in sys.argv:
+            sys.argv.append('--admin')
         _run_app(config, port=port, nodes=None, once=False, web_mode=True)
 
 @cli.command()
 @click.option('--port', '-p', type=int, help='Web server port (overrides config).')
+@click.option('--admin', is_flag=True, help='Start web server in administrative mode (enables privileged actions).')
 @click.pass_context
-def web(ctx, port):
+def web(ctx, port, admin):
     """Launch the web dashboard."""
+    # If called as a subcommand with --admin, ensure argv contains --admin so server detection sees it
+    import sys
+    if admin and '--admin' not in sys.argv:
+        sys.argv.append('--admin')
+    # Also propagate admin from top-level invocation if present in ctx.obj
+    try:
+        if not admin and ctx and isinstance(ctx.obj, dict) and ctx.obj.get('admin'):
+            if '--admin' not in sys.argv:
+                sys.argv.append('--admin')
+    except Exception:
+        pass
     _run_app(ctx.obj['config_path'], port, nodes=None, once=False, web_mode=True)
 
 @cli.command(name="cli")