wasm-cli 0.13.16__py3-none-any.whl → 0.14.1__py3-none-any.whl

wasm/__init__.py

@@ -8,7 +8,7 @@ WASM - Web App System Management
 A robust CLI tool for deploying and managing web applications on Linux servers.
 """
 
-__version__ = "0.13.16"
+__version__ = "0.14.1"
 __author__ = "Yago López Prado"
 __license__ = "WASM-NCSAL"
 

wasm/cli/commands/backup.py

@@ -105,6 +105,7 @@ def _backup_create(args: Namespace, verbose: bool) -> int:
     include_env = not getattr(args, "no_env", False)
     include_node_modules = getattr(args, "include_node_modules", False)
     include_build = getattr(args, "include_build", False)
+    include_databases = getattr(args, "include_databases", False)
     tags = getattr(args, "tags", None)
     
     if not domain:
@@ -127,6 +128,7 @@ def _backup_create(args: Namespace, verbose: bool) -> int:
             include_env=include_env,
             include_node_modules=include_node_modules,
             include_build=include_build,
+            include_databases=include_databases,
             tags=tag_list,
         )
         
@@ -135,7 +137,13 @@ def _backup_create(args: Namespace, verbose: bool) -> int:
         logger.info(f"  Size: {metadata.size_human}")
         if metadata.git_commit:
             logger.info(f"  Commit: {metadata.git_commit} ({metadata.git_branch})")
-        
+        if metadata.database_backups:
+            db_count = len(metadata.database_backups)
+            logger.info(f"  Databases: {db_count} backed up")
+            for db_info in metadata.database_backups:
+                size_mb = db_info.get("size_bytes", 0) / (1024 * 1024)
+                logger.info(f"    - {db_info['engine']}/{db_info['name']} ({size_mb:.1f} MB)")
+
         return 0
         
     except BackupError as e:
@@ -195,7 +203,7 @@ def _backup_list(args: Namespace, verbose: bool) -> int:
                 by_domain[backup.domain].append(backup)
             
             for dom, dom_backups in by_domain.items():
-                logger.info(f"\n📦 {dom}")
+                logger.info(f"\n[{dom}]")
                 _print_backup_table(dom_backups, logger, indent=True)
         
         return 0
@@ -226,7 +234,7 @@ def _print_backup_table(backups, logger, indent: bool = False):
             desc_str = f" - {backup.description}"
         
         logger.info(
-            f"{prefix}• {backup.id}: {backup.size_human}, "
+            f"{prefix}- {backup.id}: {backup.size_human}, "
             f"{backup.age}{commit_str}{tags_str}{desc_str}"
         )
 
@@ -359,17 +367,17 @@ def _backup_verify(args: Namespace, verbose: bool) -> int:
         
         if result["valid"]:
             logger.success("Backup is valid")
-            if result.get("checksum_verified"):
-                logger.info("  ✓ Checksum verified")
-            if result.get("archive_valid"):
-                logger.info(f"  ✓ Archive valid ({result.get('file_count', '?')} files)")
+            if result.get("checksum_ok"):
+                logger.info("  [OK] Checksum verified")
+            if result.get("files_ok"):
+                logger.info(f"  [OK] Archive valid ({result.get('file_count', '?')} files)")
         else:
             logger.error("Backup is invalid")
             for err in result["errors"]:
-                logger.error(f"  ✗ {err}")
-        
+                logger.error(f"  [ERROR] {err}")
+
         for warn in result.get("warnings", []):
-            logger.warning(f"  ⚠ {warn}")
+            logger.warning(f"  [WARN] {warn}")
         
         return 0 if result["valid"] else 1
         

wasm/cli/commands/config.py

@@ -0,0 +1,96 @@
+"""
+Config command handlers for WASM.
+
+Commands for managing WASM configuration files.
+"""
+
+from argparse import Namespace
+
+from wasm.core.config import Config, DEFAULT_CONFIG_PATH
+from wasm.core.logger import Logger
+
+
+def handle_config(args: Namespace) -> int:
+    """
+    Handle config commands.
+
+    Args:
+        args: Parsed arguments.
+
+    Returns:
+        Exit code.
+    """
+    action = args.action
+
+    handlers = {
+        "upgrade": _handle_upgrade,
+        "show": _handle_show,
+        "path": _handle_path,
+    }
+
+    handler = handlers.get(action)
+    if handler:
+        return handler(args)
+
+    # No action specified, show help
+    logger = Logger(verbose=getattr(args, "verbose", False))
+    logger.info("Usage: wasm config <command>")
+    logger.info("")
+    logger.info("Commands:")
+    logger.info("  upgrade    Upgrade config file with new defaults")
+    logger.info("  show       Show current configuration")
+    logger.info("  path       Show config file path")
+    return 0
+
+
+def _handle_upgrade(args: Namespace) -> int:
+    """Handle config upgrade command."""
+    quiet = getattr(args, "quiet", False)
+    logger = Logger(verbose=getattr(args, "verbose", False))
+
+    if not quiet:
+        logger.info("Upgrading configuration file...")
+
+    config = Config()
+    result = config.upgrade()
+
+    if "error" in result:
+        if not quiet:
+            logger.error(f"Failed to upgrade config: {result['error']}")
+        return 1
+
+    if result["upgraded"]:
+        if not quiet:
+            logger.success(f"Configuration upgraded! Added {len(result['added_keys'])} new option(s):")
+            for key in result["added_keys"][:10]:  # Show first 10
+                logger.info(f"  + {key}")
+            if len(result["added_keys"]) > 10:
+                logger.info(f"  ... and {len(result['added_keys']) - 10} more")
+    else:
+        if not quiet:
+            logger.success("Configuration is already up to date")
+
+    return 0
+
+
+def _handle_show(args: Namespace) -> int:
+    """Handle config show command."""
+    import yaml
+
+    logger = Logger(verbose=getattr(args, "verbose", False))
+    config = Config()
+
+    logger.header("Current Configuration")
+    print(yaml.dump(config.to_dict(), default_flow_style=False, sort_keys=False))
+
+    return 0
+
+
+def _handle_path(args: Namespace) -> int:
+    """Handle config path command."""
+    logger = Logger(verbose=getattr(args, "verbose", False))
+
+    logger.key_value("Config file", str(DEFAULT_CONFIG_PATH))
+    logger.key_value("Exists", "Yes" if DEFAULT_CONFIG_PATH.exists() else "No")
+
+    return 0

wasm/cli/commands/db.py

@@ -934,9 +934,10 @@ def _db_connect(args: Namespace, verbose: bool) -> int:
         
         logger.info(f"Connecting to {manager.DISPLAY_NAME}...")
         logger.info(f"Command: {' '.join(cmd)}")
-        
+
         # Execute interactively
-        return subprocess.call(cmd)
+        result = subprocess.run(cmd)
+        return result.returncode
     except Exception as e:
         logger.error(str(e))
         return 1

wasm/cli/commands/health.py

@@ -0,0 +1,231 @@
+# Copyright (c) 2024-2025 Yago López Prado
+# Licensed under WASM-NCSAL 1.0 (Commercial use prohibited)
+# https://github.com/Perkybeet/wasm/blob/main/LICENSE
+
+"""
+Health check command for WASM.
+
+Provides system-wide health diagnostics.
+"""
+
+import shutil
+from argparse import Namespace
+from datetime import datetime
+from pathlib import Path
+
+from wasm.core.config import Config
+from wasm.core.logger import Logger
+
+
+def _print_status(logger: Logger, key: str, value: str, status: str) -> None:
+    """Print a key-value pair with status indicator."""
+    if status == "ok":
+        indicator = "\033[32m[OK]\033[0m"
+    elif status == "warning":
+        indicator = "\033[33m[!]\033[0m"
+    elif status == "error":
+        indicator = "\033[31m[X]\033[0m"
+    else:  # info
+        indicator = "\033[34m[i]\033[0m"
+
+    print(f"  {indicator} {key}: {value}")
+
+
+def handle_health(args: Namespace) -> int:
+    """
+    Handle the health check command.
+
+    Performs system diagnostics and shows overall health status.
+    """
+    logger = Logger(verbose=args.verbose)
+    config = Config()
+
+    logger.header("System Health Check")
+    logger.blank()
+
+    issues = []
+    warnings = []
+
+    # 1. Check disk space
+    logger.info("Checking disk space...")
+    try:
+        apps_dir = config.apps_directory
+        if apps_dir.exists():
+            stat = shutil.disk_usage(str(apps_dir))
+            free_gb = stat.free / (1024 ** 3)
+            total_gb = stat.total / (1024 ** 3)
+            used_percent = ((stat.total - stat.free) / stat.total) * 100
+
+            if free_gb < 1.0:
+                issues.append(f"Low disk space: {free_gb:.1f}GB free")
+                _print_status(logger, "Disk Space", f"{free_gb:.1f}GB free / {total_gb:.1f}GB total ({used_percent:.0f}% used)", "error")
+            elif free_gb < 5.0:
+                warnings.append(f"Disk space is getting low: {free_gb:.1f}GB free")
+                _print_status(logger, "Disk Space", f"{free_gb:.1f}GB free / {total_gb:.1f}GB total ({used_percent:.0f}% used)", "warning")
+            else:
+                _print_status(logger, "Disk Space", f"{free_gb:.1f}GB free / {total_gb:.1f}GB total ({used_percent:.0f}% used)", "ok")
+        else:
+            _print_status(logger, "Disk Space", "Apps directory not found", "warning")
+    except Exception as e:
+        warnings.append(f"Could not check disk space: {e}")
+
+    # 2. Check web servers
+    logger.blank()
+    logger.info("Checking web servers...")
+
+    from wasm.managers.nginx_manager import NginxManager
+    from wasm.managers.apache_manager import ApacheManager
+
+    nginx = NginxManager(verbose=args.verbose)
+    apache = ApacheManager(verbose=args.verbose)
+
+    nginx_installed = nginx.is_installed()
+    apache_installed = apache.is_installed()
+
+    if nginx_installed:
+        nginx_status = nginx.get_status()
+        if nginx_status.get("active"):
+            _print_status(logger, "Nginx", "Running", "ok")
+        else:
+            issues.append("Nginx is installed but not running")
+            _print_status(logger, "Nginx", "Stopped", "error")
+    else:
+        _print_status(logger, "Nginx", "Not installed", "info")
+
+    if apache_installed:
+        apache_status = apache.get_status()
+        if apache_status.get("active"):
+            _print_status(logger, "Apache", "Running", "ok")
+        else:
+            warnings.append("Apache is installed but not running")
+            _print_status(logger, "Apache", "Stopped", "warning")
+    else:
+        _print_status(logger, "Apache", "Not installed", "info")
+
+    if not nginx_installed and not apache_installed:
+        issues.append("No web server installed")
+
+    # 3. Check deployed applications
+    logger.blank()
+    logger.info("Checking deployed applications...")
+
+    from wasm.core.store import get_store
+    from wasm.managers.service_manager import ServiceManager
+
+    store = get_store()
+    service_manager = ServiceManager(verbose=args.verbose)
+
+    apps = store.list_apps()
+    apps_running = 0
+    apps_stopped = 0
+    apps_failed = 0
+
+    for app in apps:
+        try:
+            status = service_manager.status(app.domain.replace(".", "-"))
+            if status.get("active"):
+                apps_running += 1
+            else:
+                apps_stopped += 1
+                warnings.append(f"App '{app.domain}' is not running")
+        except Exception:
+            apps_failed += 1
+
+    total_apps = len(apps)
+    if total_apps > 0:
+        if apps_stopped > 0 or apps_failed > 0:
+            _print_status(logger, "Applications", f"{apps_running}/{total_apps} running, {apps_stopped} stopped", "warning")
+        else:
+            _print_status(logger, "Applications", f"{apps_running}/{total_apps} running", "ok")
+    else:
+        _print_status(logger, "Applications", "No applications deployed", "info")
+
+    # 4. Check SSL certificates
+    logger.blank()
+    logger.info("Checking SSL certificates...")
+
+    from wasm.managers.cert_manager import CertManager
+    cert_manager = CertManager(verbose=args.verbose)
+
+    try:
+        certs = cert_manager.list_certificates()
+        expiring_soon = []
+
+        for cert in certs:
+            if cert.get("expires"):
+                try:
+                    expires = datetime.fromisoformat(cert["expires"].replace("Z", "+00:00"))
+                    days_left = (expires - datetime.now(expires.tzinfo)).days
+                    if days_left < 7:
+                        issues.append(f"Certificate for {cert['domain']} expires in {days_left} days")
+                        expiring_soon.append(cert["domain"])
+                    elif days_left < 30:
+                        warnings.append(f"Certificate for {cert['domain']} expires in {days_left} days")
+                        expiring_soon.append(cert["domain"])
+                except Exception:
+                    pass
+
+        if expiring_soon:
+            _print_status(logger, "SSL Certificates", f"{len(certs)} total, {len(expiring_soon)} expiring soon", "warning")
+        elif certs:
+            _print_status(logger, "SSL Certificates", f"{len(certs)} total, all valid", "ok")
+        else:
+            _print_status(logger, "SSL Certificates", "None configured", "info")
+    except Exception as e:
+        _print_status(logger, "SSL Certificates", f"Could not check: {e}", "warning")
+
+    # 5. Check system resources
+    logger.blank()
+    logger.info("Checking system resources...")
+
+    try:
+        # Memory check using /proc/meminfo
+        with open("/proc/meminfo") as f:
+            meminfo = {}
+            for line in f:
+                parts = line.split(":")
+                if len(parts) == 2:
+                    key = parts[0].strip()
+                    value = parts[1].strip().split()[0]
+                    meminfo[key] = int(value)
+
+        total_mem = meminfo.get("MemTotal", 0) / 1024 / 1024  # GB
+        free_mem = (meminfo.get("MemAvailable", 0) or meminfo.get("MemFree", 0)) / 1024 / 1024  # GB
+        used_percent = ((total_mem - free_mem) / total_mem) * 100 if total_mem > 0 else 0
+
+        if used_percent > 90:
+            issues.append(f"High memory usage: {used_percent:.0f}%")
+            _print_status(logger, "Memory", f"{free_mem:.1f}GB free / {total_mem:.1f}GB total ({used_percent:.0f}% used)", "error")
+        elif used_percent > 75:
+            warnings.append(f"Memory usage is high: {used_percent:.0f}%")
+            _print_status(logger, "Memory", f"{free_mem:.1f}GB free / {total_mem:.1f}GB total ({used_percent:.0f}% used)", "warning")
+        else:
+            _print_status(logger, "Memory", f"{free_mem:.1f}GB free / {total_mem:.1f}GB total ({used_percent:.0f}% used)", "ok")
+    except Exception as e:
+        _print_status(logger, "Memory", f"Could not check: {e}", "warning")
+
+    # Summary
+    logger.blank()
+    logger.blank()
+
+    if issues:
+        logger.error(f"Health check found {len(issues)} issue(s):")
+        for issue in issues:
+            logger.error(f"  - {issue}")
+        logger.blank()
+
+    if warnings:
+        logger.warning(f"Health check found {len(warnings)} warning(s):")
+        for warning in warnings:
+            logger.warning(f"  - {warning}")
+        logger.blank()
+
+    if not issues and not warnings:
+        logger.success("All systems healthy!")
+        return 0
+    elif issues:
+        logger.error("System has issues that need attention.")
+        return 1
+    else:
+        logger.warning("System is healthy with minor warnings.")
+        return 0

wasm/cli/commands/monitor.py

@@ -9,6 +9,11 @@ from argparse import Namespace
 
 from wasm.core.logger import Logger
 from wasm.core.exceptions import WASMError, MonitorError, EmailError
+from wasm.monitor import (
+    DEFAULT_SCAN_INTERVAL,
+    DEFAULT_CPU_THRESHOLD,
+    DEFAULT_MEMORY_THRESHOLD,
+)
 
 
 def handle_monitor(args: Namespace) -> int:
@@ -348,9 +353,9 @@ def _handle_config(args: Namespace) -> int:
     # General settings
     logger.info("")
     logger.key_value("Enabled", str(config.get("monitor.enabled", False)))
-    logger.key_value("Scan Interval", f"{config.get('monitor.scan_interval', 3600)}s")
-    logger.key_value("CPU Threshold", f"{config.get('monitor.cpu_threshold', 80.0)}%")
-    logger.key_value("Memory Threshold", f"{config.get('monitor.memory_threshold', 80.0)}%")
+    logger.key_value("Scan Interval", f"{config.get('monitor.scan_interval', DEFAULT_SCAN_INTERVAL)}s")
+    logger.key_value("CPU Threshold", f"{config.get('monitor.cpu_threshold', DEFAULT_CPU_THRESHOLD)}%")
+    logger.key_value("Memory Threshold", f"{config.get('monitor.memory_threshold', DEFAULT_MEMORY_THRESHOLD)}%")
     
     # Actions
     logger.info("")

wasm/cli/commands/setup.py

@@ -12,7 +12,7 @@ from typing import Dict, List, Optional, Tuple
 from wasm.core.logger import Logger
 from wasm.core.exceptions import WASMError
 from wasm.core.config import DEFAULT_APPS_DIR, DEFAULT_LOG_DIR, DEFAULT_CONFIG_PATH
-from wasm.core.utils import command_exists, run_command, run_command_sudo
+from wasm.core.utils import command_exists, run_command, run_command_sudo, run_trusted_installer
 
 
 def handle_setup(args: Namespace) -> int:
@@ -361,20 +361,20 @@ def _handle_init(args: Namespace) -> int:
     
     if config_choices.get("install_nodejs") and not command_exists("node"):
         logger.substep("Installing Node.js 20.x LTS...")
-        
-        # Install Node.js from NodeSource
-        result = run_command(
-            "curl -fsSL https://deb.nodesource.com/setup_20.x | bash -",
-            shell=True
-        )
-        if result.success:
-            result = run_command_sudo(["apt-get", "install", "-y", "nodejs"])
+
+        # Install Node.js from NodeSource using trusted installer
+        try:
+            result = run_trusted_installer("https://deb.nodesource.com/setup_20.x")
             if result.success:
-                logger.success("Node.js installed")
+                result = run_command_sudo(["apt-get", "install", "-y", "nodejs"])
+                if result.success:
+                    logger.success("Node.js installed")
+                else:
+                    logger.warning(f"Failed to install Node.js: {result.stderr}")
             else:
-                logger.warning(f"Failed to install Node.js: {result.stderr}")
-        else:
-            logger.warning("Failed to setup Node.js repository. Please install manually.")
+                logger.warning("Failed to setup Node.js repository. Please install manually.")
+        except Exception as e:
+            logger.warning(f"Failed to setup Node.js: {e}")
     
     # Install package managers
     selected_pms = config_choices.get("package_managers", ["npm"])
@@ -394,8 +394,12 @@ def _handle_init(args: Namespace) -> int:
         elif pm == "yarn":
             result = run_command_sudo(["npm", "install", "-g", "yarn"])
         elif pm == "bun":
-            # Bun has its own installer
-            result = run_command("curl -fsSL https://bun.sh/install | bash", shell=True)
+            # Bun has its own trusted installer
+            try:
+                result = run_trusted_installer("https://bun.sh/install")
+            except Exception as e:
+                logger.warning(f"Failed to install bun: {e}")
+                continue
         else:
             result = run_command_sudo(["npm", "install", "-g", pm])
         
@@ -467,7 +471,38 @@ def _handle_init(args: Namespace) -> int:
             logger.success(f"Created {DEFAULT_CONFIG_PATH}")
     except Exception as e:
         logger.warning(f"Could not save config file: {e}")
-    
+
+    # Install man page
+    logger.substep("Installing man page...")
+    try:
+        # Search for man page in multiple locations
+        man_source = None
+        search_paths = [
+            # Development: project root
+            Path(__file__).parent.parent.parent.parent.parent / "man" / "wasm.1",
+            # Installed via pip with data_files
+            Path("/usr/local/share/man/man1/wasm.1"),
+            Path("/usr/share/man/man1/wasm.1"),
+        ]
+
+        for path in search_paths:
+            if path.exists():
+                man_source = path
+                break
+
+        if man_source and man_source != Path("/usr/share/man/man1/wasm.1"):
+            man_dest = Path("/usr/share/man/man1/wasm.1")
+            shutil.copy(man_source, man_dest)
+            os.chmod(man_dest, 0o644)
+            run_command(["mandb", "-q"])
+            logger.success("Man page installed (man wasm)")
+        elif man_source:
+            logger.substep("Man page already installed")
+        else:
+            logger.debug("Man page source not found, skipping")
+    except Exception as e:
+        logger.debug(f"Could not install man page: {e}")
+
     # =========================================================================
     # Final Summary
     # =========================================================================

wasm/cli/commands/store.py

@@ -313,13 +313,29 @@ def _store_import(args: Namespace, verbose: bool) -> int:
     else:
         logger.step(2, 3, "No Apache sites found")
     
-    # 3. Import from systemd services (wasm-* prefix)
+    # 3. Import from systemd services (both legacy wasm-* and new format)
     logger.step(3, 3, "Scanning systemd services")
     if SYSTEMD_DIR.exists():
-        for service_file in SYSTEMD_DIR.glob("wasm-*.service"):
+        # Find all potential WASM service files
+        service_files = list(SYSTEMD_DIR.glob("wasm-*.service"))
+        # Also check for services matching domain pattern (new format)
+        for sf in SYSTEMD_DIR.glob("*.service"):
+            name = sf.stem
+            # Skip if already found as wasm-* or if it's a system service
+            if name.startswith("wasm-") or not "-" in name:
+                continue
+            # Check if it looks like a domain-based name (has hyphen, no @ or other special chars)
+            if "@" not in name and name.count("-") >= 1:
+                service_files.append(sf)
+
+        for service_file in service_files:
             # Extract app name from service file name
-            service_name = service_file.stem  # wasm-example-com
-            app_name = service_name[5:]  # example-com (remove wasm- prefix)
+            service_name = service_file.stem
+            # Handle both legacy (wasm-example-com) and new format (example-com)
+            if service_name.startswith("wasm-"):
+                app_name = service_name[5:]  # Remove wasm- prefix
+            else:
+                app_name = service_name
             
             if store.get_service(app_name):
                 continue