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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wasm-cli
-Version: 0.14.1
+Version: 0.14.2
 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.1 → wasm_cli-0.14.2}/pyproject.toml

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

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

@@ -9,7 +9,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="wasm-cli",
-    version="0.14.1",
+    version="0.14.2",
     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.1 → wasm_cli-0.14.2}/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.1"
+__version__ = "0.14.2"
 __author__ = "Yago López Prado"
 __license__ = "WASM-NCSAL"
 

{wasm_cli-0.14.1 → wasm_cli-0.14.2}/src/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}")
     

{wasm_cli-0.14.1 → wasm_cli-0.14.2}/src/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",

{wasm_cli-0.14.1 → wasm_cli-0.14.2}/src/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_cli-0.14.1 → wasm_cli-0.14.2}/src/wasm/core/logger.py

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

{wasm_cli-0.14.1 → wasm_cli-0.14.2}/src/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_cli-0.14.1 → wasm_cli-0.14.2}/src/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_cli-0.14.1 → wasm_cli-0.14.2}/src/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",
 ]

wasm_cli-0.14.2/src/wasm/deployers/helpers/turbo.py

@@ -0,0 +1,337 @@
+# Copyright (c) 2024-2025 Yago Lopez Prado
+# Licensed under WASM-NCSAL 1.0 (Commercial use prohibited)
+# https://github.com/Perkybeet/wasm/blob/main/LICENSE
+
+"""
+Turborepo helper for monorepo deployers.
+
+Handles parsing of turbo.json configuration and provides build
+pipeline information for monorepo deployments.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+from wasm.core.logger import Logger
+
+
+class TurboHelper:
+    """
+    Helper for Turborepo configuration analysis.
+
+    Provides parsing of turbo.json, build pipeline detection,
+    and dependency order calculation.
+    """
+
+    def __init__(self, logger: Optional[Logger] = None):
+        """
+        Initialize Turborepo helper.
+
+        Args:
+            logger: Logger instance for output.
+        """
+        self.logger = logger or Logger()
+        self._config: Optional[Dict] = None
+        self._config_path: Optional[Path] = None
+
+    def detect(self, app_path: Path) -> bool:
+        """
+        Detect if the project uses Turborepo.
+
+        Args:
+            app_path: Root path of the project.
+
+        Returns:
+            True if Turborepo is detected.
+        """
+        turbo_json = app_path / "turbo.json"
+        if turbo_json.exists():
+            return True
+
+        # Also check package.json for turbo field
+        package_json = app_path / "package.json"
+        if package_json.exists():
+            try:
+                with open(package_json) as f:
+                    pkg = json.load(f)
+                    return "turbo" in pkg
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        return False
+
+    def load_config(self, app_path: Path) -> Dict:
+        """
+        Load and parse turbo.json configuration.
+
+        Args:
+            app_path: Root path of the project.
+
+        Returns:
+            Parsed configuration dictionary.
+        """
+        if self._config and self._config_path == app_path:
+            return self._config
+
+        turbo_json = app_path / "turbo.json"
+
+        if not turbo_json.exists():
+            self.logger.debug("No turbo.json found, using defaults")
+            self._config = self._default_config()
+            self._config_path = app_path
+            return self._config
+
+        try:
+            with open(turbo_json) as f:
+                self._config = json.load(f)
+                self._config_path = app_path
+                return self._config
+        except (json.JSONDecodeError, OSError) as e:
+            self.logger.warning(f"Error reading turbo.json: {e}")
+            self._config = self._default_config()
+            self._config_path = app_path
+            return self._config
+
+    def _default_config(self) -> Dict:
+        """
+        Return default Turborepo configuration.
+
+        Returns:
+            Default config dictionary.
+        """
+        return {
+            "tasks": {
+                "build": {
+                    "dependsOn": ["^build"],
+                    "outputs": [".next/**", "dist/**"],
+                },
+                "dev": {
+                    "cache": False,
+                    "persistent": True,
+                },
+                "start": {
+                    "dependsOn": ["build"],
+                    "cache": False,
+                },
+            }
+        }
+
+    def get_build_command(self, app_path: Path) -> List[str]:
+        """
+        Get the build command for the monorepo.
+
+        Args:
+            app_path: Root path of the project.
+
+        Returns:
+            Build command as list of strings.
+        """
+        config = self.load_config(app_path)
+
+        # Check if build task exists
+        tasks = config.get("tasks", config.get("pipeline", {}))
+        has_build = "build" in tasks
+
+        if has_build:
+            return ["pnpm", "build"]
+
+        # Fallback to turbo run build
+        return ["pnpm", "exec", "turbo", "run", "build"]
+
+    def get_build_outputs(self, app_path: Path) -> List[str]:
+        """
+        Get expected build output directories.
+
+        Args:
+            app_path: Root path of the project.
+
+        Returns:
+            List of output directory patterns.
+        """
+        config = self.load_config(app_path)
+        tasks = config.get("tasks", config.get("pipeline", {}))
+
+        build_config = tasks.get("build", {})
+        outputs = build_config.get("outputs", [])
+
+        # Default outputs if not specified
+        if not outputs:
+            outputs = [".next/**", "dist/**", "build/**"]
+
+        return outputs
+
+    def get_task_dependencies(self, task_name: str, app_path: Path) -> List[str]:
+        """
+        Get dependencies for a specific task.
+
+        Args:
+            task_name: Name of the task (e.g., "build", "start").
+            app_path: Root path of the project.
+
+        Returns:
+            List of dependent task names.
+        """
+        config = self.load_config(app_path)
+        tasks = config.get("tasks", config.get("pipeline", {}))
+
+        task_config = tasks.get(task_name, {})
+        depends_on = task_config.get("dependsOn", [])
+
+        # Filter out topological dependencies (^)
+        direct_deps = [d.lstrip("^") for d in depends_on if not d.startswith("$")]
+
+        return direct_deps
+
+    def get_global_dependencies(self, app_path: Path) -> List[str]:
+        """
+        Get global dependencies that affect all tasks.
+
+        These are files/directories that, when changed, should
+        invalidate all caches.
+
+        Args:
+            app_path: Root path of the project.
+
+        Returns:
+            List of global dependency patterns.
+        """
+        config = self.load_config(app_path)
+
+        # Turbo 2.x format
+        global_deps = config.get("globalDependencies", [])
+
+        # Common global dependencies
+        if not global_deps:
+            global_deps = [
+                "pnpm-lock.yaml",
+                "package.json",
+                "tsconfig.json",
+            ]
+
+        return global_deps
+
+    def get_env_vars(self, app_path: Path) -> Set[str]:
+        """
+        Get environment variables that should be considered for builds.
+
+        Args:
+            app_path: Root path of the project.
+
+        Returns:
+            Set of environment variable names.
+        """
+        config = self.load_config(app_path)
+
+        env_vars = set()
+
+        # Global env (Turbo 2.x)
+        global_env = config.get("globalEnv", [])
+        env_vars.update(global_env)
+
+        # Task-specific env
+        tasks = config.get("tasks", config.get("pipeline", {}))
+        for task_config in tasks.values():
+            if isinstance(task_config, dict):
+                task_env = task_config.get("env", [])
+                env_vars.update(task_env)
+
+        return env_vars
+
+    def is_cacheable(self, task_name: str, app_path: Path) -> bool:
+        """
+        Check if a task should be cached.
+
+        Args:
+            task_name: Name of the task.
+            app_path: Root path of the project.
+
+        Returns:
+            True if the task is cacheable.
+        """
+        config = self.load_config(app_path)
+        tasks = config.get("tasks", config.get("pipeline", {}))
+
+        task_config = tasks.get(task_name, {})
+
+        # Cache is enabled by default unless explicitly disabled
+        return task_config.get("cache", True) is not False
+
+    def get_filter_args(self, workspaces: List[str]) -> List[str]:
+        """
+        Generate filter arguments for turbo to only build specific workspaces.
+
+        Args:
+            workspaces: List of workspace names to include.
+
+        Returns:
+            List of filter arguments for turbo command.
+        """
+        if not workspaces:
+            return []
+
+        args = []
+        for workspace in workspaces:
+            args.extend(["--filter", workspace])
+
+        return args
+
+    def estimate_build_timeout(self, app_path: Path, workspace_count: int) -> int:
+        """
+        Estimate build timeout based on project size.
+
+        Args:
+            app_path: Root path of the project.
+            workspace_count: Number of workspaces to build.
+
+        Returns:
+            Recommended timeout in seconds.
+        """
+        # Base timeout: 5 minutes
+        base_timeout = 300
+
+        # Add 3 minutes per workspace
+        workspace_timeout = workspace_count * 180
+
+        # Cap at 30 minutes
+        return min(base_timeout + workspace_timeout, 1800)
+
+    def get_parallel_count(self) -> Optional[int]:
+        """
+        Get recommended parallelization count for builds.
+
+        Returns:
+            Number of parallel builds, or None for default.
+        """
+        # Let Turborepo decide based on available CPUs
+        return None
+
+    def validate_config(self, app_path: Path) -> List[str]:
+        """
+        Validate turbo.json configuration.
+
+        Args:
+            app_path: Root path of the project.
+
+        Returns:
+            List of validation warnings (empty if valid).
+        """
+        warnings = []
+        config = self.load_config(app_path)
+
+        # Check for deprecated pipeline key
+        if "pipeline" in config and "tasks" not in config:
+            warnings.append(
+                "turbo.json uses deprecated 'pipeline' key. "
+                "Consider upgrading to 'tasks' (Turbo 2.x)."
+            )
+
+        # Check for build task
+        tasks = config.get("tasks", config.get("pipeline", {}))
+        if "build" not in tasks:
+            warnings.append(
+                "No 'build' task defined in turbo.json. "
+                "Build command may not work as expected."
+            )
+
+        return warnings