wasm-cli 0.14.0__tar.gz → 0.14.1__tar.gz

{wasm_cli-0.14.0/src/wasm_cli.egg-info → wasm_cli-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wasm-cli
-Version: 0.14.0
+Version: 0.14.1
 Summary: Web App System Management - Deploy and manage web applications on Linux servers
 Author: Yago López Prado
 Author-email: Yago López Prado <yago.lopez.adeje@gmail.com>

{wasm_cli-0.14.0 → wasm_cli-0.14.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wasm-cli"
-version = "0.14.0"
+version = "0.14.1"
 description = "Web App System Management - Deploy and manage web applications on Linux servers"
 readme = "README.md"
 license = { text = "WASM-NCSAL" }

{wasm_cli-0.14.0 → wasm_cli-0.14.1}/setup.py

@@ -9,7 +9,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="wasm-cli",
-    version="0.14.0",
+    version="0.14.1",
     description="Web App System Management - Deploy and manage web applications on Linux servers",
     author="Yago López Prado",
     author_email="yago.lopez.adeje@gmail.com",

{wasm_cli-0.14.0 → wasm_cli-0.14.1}/src/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.1"
 __author__ = "Yago López Prado"
 __license__ = "WASM-NCSAL"
 

{wasm_cli-0.14.0 → wasm_cli-0.14.1}/src/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-0.14.0 → wasm_cli-0.14.1}/src/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-0.14.0 → wasm_cli-0.14.1}/src/wasm/cli/commands/webapp.py

@@ -639,7 +639,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 +734,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-0.14.0 → wasm_cli-0.14.1}/src/wasm/cli/parser.py

@@ -908,6 +908,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_cli-0.14.0 → wasm_cli-0.14.1}/src/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_cli-0.14.0 → wasm_cli-0.14.1}/src/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_cli-0.14.0 → wasm_cli-0.14.1}/src/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_cli-0.14.0 → wasm_cli-0.14.1}/src/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_cli-0.14.0 → wasm_cli-0.14.1}/src/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_cli-0.14.0 → wasm_cli-0.14.1}/src/wasm/managers/backup_manager.py

@@ -46,6 +46,9 @@ class BackupMetadata:
     description: str
     includes_env: bool
     includes_node_modules: bool
+    includes_build: bool = False
+    includes_databases: bool = False
+    database_backups: List[Dict[str, Any]] = field(default_factory=list)
     git_commit: Optional[str] = None
     git_branch: Optional[str] = None
     checksum: Optional[str] = None
@@ -64,6 +67,9 @@ class BackupMetadata:
             "description": self.description,
             "includes_env": self.includes_env,
             "includes_node_modules": self.includes_node_modules,
+            "includes_build": self.includes_build,
+            "includes_databases": self.includes_databases,
+            "database_backups": self.database_backups,
             "git_commit": self.git_commit,
             "git_branch": self.git_branch,
             "checksum": self.checksum,
@@ -84,6 +90,9 @@ class BackupMetadata:
             description=data.get("description", ""),
             includes_env=data.get("includes_env", False),
             includes_node_modules=data.get("includes_node_modules", False),
+            includes_build=data.get("includes_build", False),
+            includes_databases=data.get("includes_databases", False),
+            database_backups=data.get("database_backups", []),
             git_commit=data.get("git_commit"),
             git_branch=data.get("git_branch"),
             checksum=data.get("checksum"),
@@ -269,24 +278,26 @@ class BackupManager:
         include_env: bool = True,
         include_node_modules: bool = False,
         include_build: bool = False,
+        include_databases: bool = False,
         tags: Optional[List[str]] = None,
         pre_backup_hook: Optional[str] = None,
     ) -> BackupMetadata:
         """
         Create a backup of an application.
-        
+
         Args:
             domain: Domain name of the application.
             description: Optional description for the backup.
             include_env: Include .env files in backup.
             include_node_modules: Include node_modules (large!).
             include_build: Include build artifacts.
+            include_databases: Include associated database dumps.
             tags: Optional tags for the backup.
             pre_backup_hook: Optional command to run before backup.
-            
+
         Returns:
             BackupMetadata for the created backup.
-            
+
         Raises:
             BackupError: If backup fails.
         """
@@ -378,6 +389,11 @@ class BackupManager:
         result = run_command_sudo(["sha256sum", str(backup_file)])
         checksum = result.stdout.split()[0] if result.success else None
         
+        # Backup associated databases if requested
+        database_backups = []
+        if include_databases:
+            database_backups = self._backup_databases(domain)
+
         # Create metadata
         metadata = BackupMetadata(
             id=backup_id,
@@ -390,6 +406,9 @@ class BackupManager:
             description=description,
             includes_env=include_env,
             includes_node_modules=include_node_modules,
+            includes_build=include_build,
+            includes_databases=include_databases,
+            database_backups=database_backups,
             git_commit=git_commit,
             git_branch=git_branch,
             checksum=checksum,
@@ -415,29 +434,33 @@ class BackupManager:
     def list_backups(
         self,
         domain: Optional[str] = None,
+        app_name: Optional[str] = None,
         tags: Optional[List[str]] = None,
         limit: Optional[int] = None,
     ) -> List[BackupMetadata]:
         """
         List backups for an application or all applications.
-        
+
         Args:
             domain: Filter by domain (None for all).
+            app_name: Filter by app name directly (alternative to domain).
             tags: Filter by tags.
             limit: Maximum number of backups to return.
-            
+
         Returns:
             List of BackupMetadata objects.
         """
         backups = []
-        
+
         if not self.backup_dir.exists():
             return backups
-        
+
         # Determine which directories to scan
-        if domain:
-            app_name = domain_to_app_name(domain)
+        if app_name:
             dirs_to_scan = [self._get_app_backup_dir(app_name)]
+        elif domain:
+            resolved_app_name = domain_to_app_name(domain)
+            dirs_to_scan = [self._get_app_backup_dir(resolved_app_name)]
         else:
             dirs_to_scan = [d for d in self.backup_dir.iterdir() if d.is_dir()]
         
@@ -739,11 +762,11 @@ class BackupManager:
     def _rotate_backups(self, app_name: str) -> None:
         """
         Rotate old backups to keep only the most recent ones.
-        
+
         Args:
             app_name: Application name.
         """
-        backups = self.list_backups(domain=app_name.replace("-", ".").replace("wasm-", ""))
+        backups = self.list_backups(app_name=app_name)
         
         if len(backups) > self.max_backups:
             # Delete oldest backups
@@ -753,7 +776,78 @@ class BackupManager:
                     self.logger.debug(f"Rotated old backup: {backup.id}")
                 except Exception as e:
                     self.logger.warning(f"Failed to rotate backup {backup.id}: {e}")
-    
+
+    def _backup_databases(self, domain: str) -> List[Dict[str, Any]]:
+        """
+        Backup databases associated with an application.
+
+        Args:
+            domain: Domain name of the application.
+
+        Returns:
+            List of database backup info dictionaries.
+        """
+        database_backups = []
+
+        try:
+            from wasm.core.store import WASMStore
+            from wasm.managers.database.registry import DatabaseRegistry
+        except ImportError as e:
+            self.logger.warning(f"Database backup not available: {e}")
+            return database_backups
+
+        try:
+            store = WASMStore()
+            app = store.get_app_by_domain(domain)
+
+            if not app or not app.id:
+                self.logger.debug(f"No app found in store for {domain}")
+                return database_backups
+
+            databases = store.list_databases(app_id=app.id)
+
+            if not databases:
+                self.logger.debug(f"No databases associated with {domain}")
+                return database_backups
+
+            self.logger.info(f"Backing up {len(databases)} database(s) for {domain}")
+
+            for db in databases:
+                try:
+                    manager = DatabaseRegistry.get(db.engine, verbose=self.verbose)
+
+                    if not manager:
+                        self.logger.warning(f"No manager available for {db.engine}")
+                        continue
+
+                    if not manager.is_installed():
+                        self.logger.warning(
+                            f"{db.engine} not installed, skipping {db.name}"
+                        )
+                        continue
+
+                    backup_info = manager.backup(database=db.name, compress=True)
+
+                    database_backups.append({
+                        "engine": db.engine,
+                        "name": db.name,
+                        "backup_path": str(backup_info.path),
+                        "size_bytes": backup_info.size,
+                        "created": backup_info.created.isoformat(),
+                    })
+
+                    self.logger.info(f"  Backed up {db.engine} database: {db.name}")
+
+                except Exception as e:
+                    self.logger.warning(
+                        f"  Failed to backup {db.engine} '{db.name}': {e}"
+                    )
+
+        except Exception as e:
+            self.logger.warning(f"Database backup failed: {e}")
+
+        return database_backups
+
     def verify(self, backup_id: str) -> Dict[str, Any]:
         """
         Verify a backup's integrity.
@@ -795,7 +889,7 @@ class BackupManager:
                     results["valid"] = False
                     results["errors"].append("Checksum mismatch")
                 else:
-                    results["checksum_verified"] = True
+                    results["checksum_ok"] = True
             else:
                 results["warnings"].append("Could not verify checksum")
         else:
@@ -807,7 +901,7 @@ class BackupManager:
             results["valid"] = False
             results["errors"].append("Archive is corrupted")
         else:
-            results["archive_valid"] = True
+            results["files_ok"] = True
             results["file_count"] = len(result.stdout.strip().split("\n"))
         
         return results