wasm-cli 0.14.0__py3-none-any.whl → 0.14.2__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.14.0"
+__version__ = "0.14.2"
 __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/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

wasm/cli/commands/webapp.py

@@ -202,10 +202,14 @@ def _handle_create(args: Namespace) -> int:
     logger.key_value("Package Manager", package_manager)
     logger.key_value("SSL", "Yes" if not args.no_ssl else "No")
     logger.blank()
-    
+
+    # Handle monorepo deployments specially
+    if app_type == "monorepo":
+        return _handle_monorepo_create(args, domain, env_vars, logger)
+
     # Get deployer
     deployer = get_deployer(app_type, verbose=args.verbose)
-    
+
     # Configure deployer
     deployer.configure(
         domain=domain,
@@ -217,10 +221,51 @@ def _handle_create(args: Namespace) -> int:
         env_vars=env_vars,
         package_manager=package_manager,
     )
-    
+
     # Run deployment
     deployer.deploy()
-    
+
+    return 0
+
+
+def _handle_monorepo_create(args: Namespace, domain: str, env_vars: Dict, logger: Logger) -> int:
+    """Handle monorepo deployment specially."""
+    from wasm.deployers.monorepo import MonorepoDeployer
+
+    # Parse subdomain overrides
+    subdomain_overrides = {}
+    if getattr(args, "subdomains", None):
+        for mapping in args.subdomains:
+            if ":" in mapping:
+                app_name, subdomain = mapping.split(":", 1)
+                subdomain_overrides[app_name] = subdomain
+            else:
+                logger.warning(f"Invalid subdomain mapping: {mapping} (expected app:subdomain)")
+
+    # Get workspace filter
+    workspace_filter = getattr(args, "workspaces", None)
+
+    # Get skip_database flag
+    skip_database = getattr(args, "no_database", False)
+
+    # Create and configure deployer
+    deployer = MonorepoDeployer(verbose=args.verbose)
+
+    deployer.configure(
+        domain=domain,
+        source=args.source,
+        webserver=args.webserver,
+        ssl=not args.no_ssl,
+        branch=args.branch,
+        env_vars=env_vars,
+        subdomain_overrides=subdomain_overrides,
+        workspace_filter=workspace_filter,
+        skip_database=skip_database,
+    )
+
+    # Run deployment
+    deployer.deploy()
+
     return 0
 
 
@@ -457,7 +502,7 @@ def _handle_start(args: Namespace) -> int:
 def _handle_update(args: Namespace) -> int:
     """
     Handle webapp update command with zero-downtime strategy.
-    
+
     Strategy:
     1. Create pre-update backup (for rollback)
     2. Pull/fetch new code
@@ -468,11 +513,24 @@ def _handle_update(args: Namespace) -> int:
     """
     logger = Logger(verbose=args.verbose)
     config = Config()
-    
+
+    from wasm.core.store import get_store
+    store = get_store()
+
     domain = validate_domain(args.domain)
-    app_name = domain_to_app_name(domain)
-    app_path = config.apps_directory / app_name
-    
+
+    # Consultar BD primero para obtener el app_path real
+    app = store.get_app(domain)
+
+    if app and app.app_path:
+        # Usar el path almacenado en la BD (soporta apps legacy con prefijo wasm-)
+        app_path = Path(app.app_path)
+        app_name = app_path.name
+    else:
+        # Fallback para apps no registradas en BD
+        app_name = domain_to_app_name(domain)
+        app_path = config.apps_directory / app_name
+
     if not app_path.exists():
         raise WASMError(f"Application not found: {domain}")
     
@@ -639,7 +697,7 @@ def _handle_delete(args: Namespace) -> int:
         try:
             status = service_manager.status(app_name)
             if status.get("exists"):
-                logger.key_value("Stop and remove service", f"wasm-{app_name}")
+                logger.key_value("Stop and remove service", app_name)
         except Exception:
             pass
 
@@ -734,9 +792,9 @@ def _handle_logs(args: Namespace) -> int:
     domain = validate_domain(args.domain)
     app_name = domain_to_app_name(domain)
     
-    # Get service name (ServiceManager adds prefix internally)
-    service_name = f"wasm-{app_name}"
-    
+    # Get resolved service name (handles both legacy wasm-* and new format)
+    service_name = service_manager._resolve_service_name(app_name)
+
     if args.follow:
         # Use journalctl directly for follow mode
         import subprocess

wasm/cli/parser.py

@@ -36,7 +36,7 @@ def create_parser() -> argparse.ArgumentParser:
 CLI tool for deploying and managing web applications on Linux servers.
 Automates: Git clone, build, systemd, Nginx/Apache, SSL (Let's Encrypt).
 
-Supported app types: nextjs, nodejs, vite, python, static
+Supported app types: nextjs, nodejs, vite, python, static, monorepo
 
 QUICK START:
   wasm setup init              Initialize directories (first time, requires sudo)
@@ -179,7 +179,7 @@ def _add_webapp_commands(subparsers) -> None:
     )
     create.add_argument(
         "--type", "-t",
-        choices=["nextjs", "nodejs", "vite", "python", "static", "auto"],
+        choices=["nextjs", "nodejs", "vite", "python", "static", "monorepo", "auto"],
         default="auto",
         help="Application type (default: auto-detect)",
     )
@@ -213,7 +213,26 @@ def _add_webapp_commands(subparsers) -> None:
         default="auto",
         help="Package manager to use (default: auto-detect)",
     )
-    
+
+    # Monorepo-specific options
+    create.add_argument(
+        "--subdomains",
+        nargs="+",
+        metavar="APP:SUBDOMAIN",
+        help="Subdomain mapping for monorepo apps (e.g., erp-backend:api web-gateway:app)",
+    )
+    create.add_argument(
+        "--workspaces",
+        nargs="+",
+        metavar="NAME",
+        help="Specific workspace apps to deploy (default: all)",
+    )
+    create.add_argument(
+        "--no-database",
+        action="store_true",
+        help="Skip database provisioning for monorepo",
+    )
+
     # list (alias: ls)
     subparsers.add_parser(
         "list",
@@ -908,6 +927,11 @@ def _add_backup_parser(subparsers) -> None:
         action="store_true",
         help="Include build artifacts (.next, dist, build)",
     )
+    create.add_argument(
+        "--include-databases", "--include-db",
+        action="store_true",
+        help="Include associated database dumps in backup",
+    )
     create.add_argument(
         "--tags", "-t",
         help="Comma-separated tags for the backup",

wasm/completions/_wasm

@@ -14,14 +14,38 @@
 
 # Helper functions
 _wasm_apps() {
-    local apps_dir="/var/www/apps"
     local apps=()
-    if [[ -d "$apps_dir" ]]; then
-        for app in "$apps_dir"/*/; do
-            if [[ -d "$app" ]]; then
-                apps+=("$(basename "$app")")
-            fi
-        done 2>/dev/null
+
+    # Try to get domains from SQLite store (fast and accurate)
+    local db_path="/var/lib/wasm/wasm.db"
+    if [[ ! -f "$db_path" ]]; then
+        db_path="$HOME/.local/share/wasm/wasm.db"
+    fi
+
+    if [[ -f "$db_path" ]] && command -v sqlite3 &>/dev/null; then
+        apps=(${(f)"$(sqlite3 "$db_path" "SELECT domain FROM apps" 2>/dev/null)"})
+    else
+        # Fallback: list app directories and convert names to domains
+        local apps_dir="/var/www/apps"
+        if [[ -d "$apps_dir" ]]; then
+            for app in "$apps_dir"/*/; do
+                if [[ -d "$app" ]]; then
+                    local name
+                    name=$(basename "$app")
+                    # Convert directory name to domain format
+                    # Legacy: wasm-example-com -> example.com
+                    # New: example-com -> example.com
+                    if [[ "$name" == wasm-* ]]; then
+                        apps+=("${${name#wasm-}//\-/.}")
+                    elif [[ "$name" == *-* ]]; then
+                        # New format: convert hyphens to dots
+                        apps+=("${name//\-/.}")
+                    else
+                        apps+=("$name")
+                    fi
+                fi
+            done 2>/dev/null
+        fi
     fi
     _describe -t apps 'deployed applications' apps
 }

wasm/completions/wasm.bash

@@ -16,11 +16,35 @@
 
 # Helper function to get list of deployed apps (domains)
 _wasm_get_apps() {
+    # Try to get domains from SQLite store (fast and accurate)
+    local db_path="/var/lib/wasm/wasm.db"
+    if [[ ! -f "$db_path" ]]; then
+        db_path="$HOME/.local/share/wasm/wasm.db"
+    fi
+
+    if [[ -f "$db_path" ]] && command -v sqlite3 &>/dev/null; then
+        sqlite3 "$db_path" "SELECT domain FROM apps" 2>/dev/null
+        return
+    fi
+
+    # Fallback: list app directories and convert names to domains
     local apps_dir="/var/www/apps"
     if [[ -d "$apps_dir" ]]; then
         for app in "$apps_dir"/*/; do
             if [[ -d "$app" ]]; then
-                basename "$app"
+                local name
+                name=$(basename "$app")
+                # Convert directory name to domain format
+                # Legacy: wasm-example-com -> example.com
+                # New: example-com -> example.com
+                if [[ "$name" == wasm-* ]]; then
+                    echo "${name#wasm-}" | tr '-' '.'
+                elif [[ "$name" == *-* ]]; then
+                    # New format: convert hyphens to dots
+                    echo "$name" | tr '-' '.'
+                else
+                    echo "$name"
+                fi
             fi
         done 2>/dev/null
     fi

wasm/completions/wasm.fish

@@ -14,11 +14,34 @@ complete -c wasm -f
 
 # Helper functions
 function __wasm_get_apps
+    # Try to get domains from SQLite store (fast and accurate)
+    set -l db_path "/var/lib/wasm/wasm.db"
+    if not test -f "$db_path"
+        set db_path "$HOME/.local/share/wasm/wasm.db"
+    end
+
+    if test -f "$db_path"; and command -v sqlite3 >/dev/null
+        sqlite3 "$db_path" "SELECT domain FROM apps" 2>/dev/null
+        return
+    end
+
+    # Fallback: list app directories and convert names to domains
     set -l apps_dir "/var/www/apps"
     if test -d "$apps_dir"
         for app in $apps_dir/*/
             if test -d "$app"
-                basename "$app"
+                set -l name (basename "$app")
+                # Convert directory name to domain format
+                # Legacy: wasm-example-com -> example.com
+                # New: example-com -> example.com
+                if string match -q 'wasm-*' "$name"
+                    string replace 'wasm-' '' "$name" | string replace -a '-' '.'
+                else if string match -q '*-*' "$name"
+                    # New format: convert hyphens to dots
+                    string replace -a '-' '.' "$name"
+                else
+                    echo "$name"
+                end
             end
         end 2>/dev/null
     end

wasm/core/__init__.py

@@ -11,6 +11,7 @@ from wasm.core.store import (
     Service,
     Database,
     DatabaseUser,
+    MonorepoWorkspace,
     AppType,
     AppStatus,
     WebServer,
@@ -28,6 +29,7 @@ __all__ = [
     "Service",
     "Database",
     "DatabaseUser",
+    "MonorepoWorkspace",
     "AppType",
     "AppStatus",
     "WebServer",

wasm/core/logger.py

@@ -63,6 +63,8 @@ class Icons:
     CLOCK = "⏱"
     FOLDER = "📁"
     FILE = "📄"
+    DATABASE = "🗄️"
+    SEARCH = "🔍"
 
 
 class LogLevel(Enum):

wasm/core/store.py

@@ -35,6 +35,7 @@ class AppType(str, Enum):
     PYTHON = "python"
     VITE = "vite"
     STATIC = "static"
+    MONOREPO = "monorepo"
     UNKNOWN = "unknown"
 
 
@@ -211,6 +212,31 @@ class DatabaseUser:
         return cls(**dict(row))
 
 
+@dataclass
+class MonorepoWorkspace:
+    """
+    Configuration for a workspace app within a monorepo.
+
+    Used by MonorepoDeployer to track individual apps in a Turborepo/pnpm
+    workspace monorepo.
+    """
+    name: str = ""
+    path: str = ""
+    app_type: str = AppType.UNKNOWN.value
+    subdomain: str = ""
+    port: int = 3000
+    start_command: Optional[str] = None
+    health_check: str = "/"
+    env_vars: Dict[str, str] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        d = asdict(self)
+        if isinstance(d.get('env_vars'), dict):
+            d['env_vars'] = json.dumps(d['env_vars'])
+        return d
+
+
 # Schema version for migrations
 SCHEMA_VERSION = 1
 

wasm/core/utils.py

@@ -219,12 +219,27 @@ def sanitize_name(name: str) -> str:
 def domain_to_app_name(domain: str) -> str:
     """
     Convert a domain to an application name.
-    
+
     Args:
         domain: Domain name (e.g., "myapp.example.com").
-        
+
+    Returns:
+        Application name (e.g., "myapp-example-com").
+    """
+    return sanitize_name(domain)
+
+
+def legacy_app_name(domain: str) -> str:
+    """
+    Get legacy app name format (with wasm- prefix).
+
+    Used for backwards compatibility with apps created before v0.14.1.
+
+    Args:
+        domain: Domain name (e.g., "myapp.example.com").
+
     Returns:
-        Application name (e.g., "wasm-myapp-example-com").
+        Legacy application name (e.g., "wasm-myapp-example-com").
     """
     return f"wasm-{sanitize_name(domain)}"
 

wasm/deployers/__init__.py

@@ -2,10 +2,12 @@
 
 from wasm.deployers.base import BaseDeployer
 from wasm.deployers.registry import DeployerRegistry, get_deployer, detect_app_type
+from wasm.deployers.monorepo import MonorepoDeployer
 
 __all__ = [
     "BaseDeployer",
     "DeployerRegistry",
     "get_deployer",
     "detect_app_type",
+    "MonorepoDeployer",
 ]

wasm/deployers/base.py

@@ -899,9 +899,9 @@ class BaseDeployer(ABC):
         app = self.store.get_app(self.domain)
         app_id = app.id if app else None
         
-        # Service name without prefix (store handles that)
+        # Service name (no prefix for new format)
         service_name = self.app_name
-        service_file = SYSTEMD_DIR / f"wasm-{self.app_name}.service"
+        service_file = SYSTEMD_DIR / f"{self.app_name}.service"
         
         existing_service = self.store.get_service(service_name)
         
@@ -1142,7 +1142,7 @@ class BaseDeployer(ABC):
         # Basic info
         protocol = "https" if ssl_obtained else "http"
         self.logger.key_value("URL", f"{protocol}://{self.domain}")
-        self.logger.key_value("Service", f"wasm-{self.app_name}")
+        self.logger.key_value("Service", self.app_name)
         self.logger.key_value("Port", str(self.port))
         self.logger.key_value("App Path", str(self.app_path))
 

wasm/deployers/helpers/__init__.py

@@ -12,9 +12,13 @@ to improve maintainability and testability.
 from wasm.deployers.helpers.package_manager import PackageManagerHelper
 from wasm.deployers.helpers.path_resolver import PathResolver
 from wasm.deployers.helpers.prisma import PrismaHelper
+from wasm.deployers.helpers.workspace import WorkspaceHelper
+from wasm.deployers.helpers.turbo import TurboHelper
 
 __all__ = [
     "PackageManagerHelper",
     "PathResolver",
     "PrismaHelper",
+    "WorkspaceHelper",
+    "TurboHelper",
 ]