wasm-cli 0.15.2__tar.gz → 0.15.4__tar.gz

{wasm_cli-0.15.2/src/wasm_cli.egg-info → wasm_cli-0.15.4}/PKG-INFO

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

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

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/setup.py

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

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/cli/commands/cert.py

@@ -85,6 +85,7 @@ def _handle_create(args: Namespace) -> int:
         apache=args.apache,
         dry_run=args.dry_run,
         additional_domains=additional_domains,
+        expand=getattr(args, "expand", False),
     )
     
     if args.dry_run:

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/cli/commands/webapp.py

@@ -201,6 +201,11 @@ def _handle_create(args: Namespace) -> int:
     logger.key_value("Port", str(port))
     logger.key_value("Package Manager", package_manager)
     logger.key_value("SSL", "Yes" if not args.no_ssl else "No")
+    include_www = getattr(args, "www", False)
+    if not args.no_ssl and include_www:
+        from wasm.validators.domain import should_include_www
+        if should_include_www(domain):
+            logger.key_value("WWW", f"www.{domain} included")
     logger.blank()
 
     # Handle monorepo deployments specially
@@ -224,6 +229,7 @@ def _handle_create(args: Namespace) -> int:
         branch=args.branch,
         env_vars=env_vars,
         package_manager=package_manager,
+        include_www=getattr(args, "www", False),
     )
 
     # Run deployment

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/cli/interactive.py

@@ -123,13 +123,16 @@ class InteractiveMode:
             return self._run_webapp_command("list")
         elif action == "logs":
             domain = self._prompt_domain("Enter application domain")
-            return self._run_webapp_command("logs", domain)
-        elif action in ["status", "update", "restart", "stop", "start"]:
+            return self._webapp_logs(domain)
+        elif action == "update":
+            domain = self._prompt_domain("Enter application domain")
+            return self._webapp_update(domain)
+        elif action in ["status", "restart", "stop", "start"]:
             domain = self._prompt_domain("Enter application domain")
             return self._run_webapp_command(action, domain)
         elif action == "delete":
             domain = self._prompt_domain("Enter application domain")
-            return self._run_webapp_command("delete", domain, force=True)
+            return self._run_webapp_command("delete", domain, force=True, keep_files=False)
         
         return 0
     
@@ -216,7 +219,21 @@ class InteractiveMode:
         answers = inquirer.prompt(questions, theme=GreenPassion())
         if not answers:
             return 0
-        
+
+        # Ask about www if SSL enabled and domain is a base domain
+        from wasm.validators.domain import should_include_www
+        include_www = False
+        if answers["ssl"] and should_include_www(answers["domain"]):
+            www_questions = [
+                inquirer.Confirm(
+                    "include_www",
+                    message=f"Include www.{answers['domain']} in certificate and web server config?",
+                    default=True,
+                ),
+            ]
+            www_answers = inquirer.prompt(www_questions, theme=GreenPassion())
+            include_www = www_answers.get("include_www", True) if www_answers else False
+
         # Build arguments
         from argparse import Namespace
         args = Namespace(
@@ -230,11 +247,59 @@ class InteractiveMode:
             branch=answers["branch"] or None,
             no_ssl=not answers["ssl"],
             env_file=answers["env_file"] or None,
+            www=include_www,
         )
-        
+
         from wasm.cli.commands.webapp import handle_webapp
         return handle_webapp(args)
     
+    def _webapp_logs(self, domain: str) -> int:
+        """Handle webapp logs flow with interactive prompts."""
+        questions = [
+            inquirer.Text(
+                "lines",
+                message="Number of log lines to show",
+                default="50",
+                validate=lambda _, x: x.isdigit() and int(x) > 0 or "Must be a positive number",
+            ),
+            inquirer.Confirm(
+                "follow",
+                message="Follow log output in real time?",
+                default=False,
+            ),
+        ]
+
+        answers = inquirer.prompt(questions, theme=GreenPassion())
+        if not answers:
+            return 0
+
+        return self._run_webapp_command(
+            "logs",
+            domain,
+            lines=int(answers["lines"]),
+            follow=answers["follow"],
+        )
+
+    def _webapp_update(self, domain: str) -> int:
+        """Handle webapp update flow with interactive prompts."""
+        questions = [
+            inquirer.Text(
+                "branch",
+                message="Git branch to update from (leave empty for default)",
+                default="",
+            ),
+        ]
+
+        answers = inquirer.prompt(questions, theme=GreenPassion())
+        if not answers:
+            return 0
+
+        return self._run_webapp_command(
+            "update",
+            domain,
+            branch=answers["branch"] or None,
+        )
+
     def _site_flow(self) -> int:
         """Handle site interactive flow."""
         questions = [
@@ -348,7 +413,10 @@ class InteractiveMode:
             return self._service_create()
         elif action == "list":
             return self._run_command("service", "list")
-        elif action in ["status", "start", "stop", "restart", "logs", "delete"]:
+        elif action == "logs":
+            name = self._prompt_text("Enter service name")
+            return self._service_logs(name)
+        elif action in ["status", "start", "stop", "restart", "delete"]:
             name = self._prompt_text("Enter service name")
             if action == "delete":
                 return self._run_command("service", action, name, force=True)
@@ -395,7 +463,7 @@ class InteractiveMode:
             verbose=self.verbose,
             action="create",
             name=answers["name"],
-            command=answers["command"],
+            exec_command=answers["command"],
             directory=answers["directory"],
             user=answers["user"],
             description=answers["description"] or None,
@@ -404,6 +472,34 @@ class InteractiveMode:
         from wasm.cli.commands.service import handle_service
         return handle_service(args)
     
+    def _service_logs(self, name: str) -> int:
+        """Handle service logs flow with interactive prompts."""
+        questions = [
+            inquirer.Text(
+                "lines",
+                message="Number of log lines to show",
+                default="50",
+                validate=lambda _, x: x.isdigit() and int(x) > 0 or "Must be a positive number",
+            ),
+            inquirer.Confirm(
+                "follow",
+                message="Follow log output in real time?",
+                default=False,
+            ),
+        ]
+
+        answers = inquirer.prompt(questions, theme=GreenPassion())
+        if not answers:
+            return 0
+
+        return self._run_command(
+            "service",
+            "logs",
+            name,
+            lines=int(answers["lines"]),
+            follow=answers["follow"],
+        )
+
     def _cert_flow(self) -> int:
         """Handle cert interactive flow."""
         questions = [
@@ -437,6 +533,8 @@ class InteractiveMode:
             domain = self._prompt_domain("Enter domain name")
             if action == "delete":
                 return self._run_command("cert", action, domain, force=True)
+            elif action == "revoke":
+                return self._run_command("cert", action, domain, delete=True)
             return self._run_command("cert", action, domain)
         
         return 0

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/cli/parser.py

@@ -206,6 +206,11 @@ def _add_webapp_commands(subparsers) -> None:
         action="store_true",
         help="Skip SSL certificate configuration",
     )
+    create.add_argument(
+        "--www",
+        action="store_true",
+        help="Include www subdomain in SSL certificate and web server config",
+    )
     create.add_argument(
         "--env-file",
         help="Path to environment file",
@@ -659,7 +664,12 @@ def _add_cert_parser(subparsers) -> None:
         action="store_true",
         help="Test without obtaining",
     )
-    
+    create.add_argument(
+        "--expand",
+        action="store_true",
+        help="Expand existing certificate to include additional domains",
+    )
+
     # cert list
     cert_sub.add_parser(
         "list",

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/deployers/base.py

@@ -95,6 +95,7 @@ class BaseDeployer(ABC):
         self.app_name: Optional[str] = None
         self.webserver: str = "nginx"
         self.ssl: bool = True
+        self.include_www: bool = False
         self.branch: Optional[str] = None
         self.env_vars: Dict[str, str] = {}
         
@@ -123,10 +124,11 @@ class BaseDeployer(ABC):
         env_vars: Optional[Dict[str, str]] = None,
         app_path: Optional[Path] = None,
         package_manager: PackageManager = "auto",
+        include_www: bool = False,
     ) -> None:
         """
         Configure the deployer.
-        
+
         Args:
             domain: Target domain.
             source: Source URL or path.
@@ -137,12 +139,16 @@ class BaseDeployer(ABC):
             env_vars: Environment variables.
             app_path: Custom application path.
             package_manager: Package manager to use (npm/pnpm/bun/auto).
+            include_www: Include www subdomain in certificate and web server config.
         """
+        from wasm.validators.domain import should_include_www
+
         self.domain = domain
         self.source = source
         self.port = port or self.DEFAULT_PORT
         self.webserver = webserver
         self.ssl = ssl
+        self.include_www = include_www and should_include_www(domain)
         self.branch = branch
         self.env_vars = env_vars or {}
         self._package_manager = package_manager
@@ -410,16 +416,23 @@ class BaseDeployer(ABC):
         Returns:
             Context dictionary.
         """
+        server_names = self.domain
+        if self.include_www:
+            server_names = f"{self.domain} www.{self.domain}"
+
         if self._nginx_advanced_config is not None:
-            return self._nginx_config_builder.build_context(
+            ctx = self._nginx_config_builder.build_context(
                 self._nginx_advanced_config,
                 self.domain,
                 ssl=self.ssl,
                 app_path=str(self.app_path),
             )
+            ctx["server_names"] = server_names
+            return ctx
 
         return {
             "domain": self.domain,
+            "server_names": server_names,
             "port": self.port,
             "app_path": str(self.app_path),
             "app_name": self.app_name,
@@ -1025,25 +1038,32 @@ class BaseDeployer(ABC):
     def obtain_certificate(self) -> bool:
         """
         Obtain SSL certificate.
-        
+
         Returns:
             True if successful.
         """
         if not self.ssl:
             return True
-        
+
         self.logger.substep(f"Domain: {self.domain}")
-        
+
+        additional_domains = None
+        if self.include_www:
+            www_domain = f"www.{self.domain}"
+            additional_domains = [www_domain]
+            self.logger.substep(f"Including: {www_domain}")
+
         # Use nginx plugin if using nginx
         nginx = self.webserver == "nginx"
         apache = self.webserver == "apache"
-        
+
         self.cert_manager.obtain(
             self.domain,
             nginx=nginx,
             apache=apache,
+            additional_domains=additional_domains,
         )
-        
+
         return True
     
     def start(self) -> bool:

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/deployers/docker_compose.py

@@ -216,11 +216,20 @@ class DockerComposeDeployer:
         self.compose_profiles = compose_profiles or []
         self.port = port
 
+    def _is_headless(self) -> bool:
+        """
+        Check if the application has no web-facing services.
+
+        Returns:
+            True if no services expose ports (headless/worker mode).
+        """
+        return not any(svc.is_web for svc in self.services)
+
     def deploy(self) -> None:
         """
         Execute the full deployment workflow.
 
-        Steps:
+        For web-facing apps (services with ports):
         1. Fetch source code
         2. Discover compose file
         3. Parse compose services
@@ -231,6 +240,9 @@ class DockerComposeDeployer:
         8. Create systemd service
         9. Start and verify
 
+        For headless/worker apps (no exposed ports):
+        Steps 6 and 7 are skipped automatically.
+
         Raises:
             DeploymentError: If any deployment step fails.
         """
@@ -246,17 +258,26 @@ class DockerComposeDeployer:
             self.logger.step(3, total_steps, "Parsing compose services")
             self._parse_compose_services()
 
+            headless = self._is_headless()
+
             self.logger.step(4, total_steps, "Configuring environment")
             self._configure_environment()
 
             self.logger.step(5, total_steps, "Building Docker images")
             self._build_images()
 
-            self.logger.step(6, total_steps, "Creating site configuration")
-            self._create_site()
+            if headless:
+                self.logger.step(6, total_steps, "Skipping Nginx (headless worker)")
+                self.logger.substep("No services expose ports, web server not needed")
+                self.logger.step(7, total_steps, "Skipping SSL (headless worker)")
+                self.logger.substep("No web-facing services, certificate not needed")
+                self.ssl = False
+            else:
+                self.logger.step(6, total_steps, "Creating site configuration")
+                self._create_site()
 
-            self.logger.step(7, total_steps, "Obtaining SSL certificate")
-            self._obtain_certificate()
+                self.logger.step(7, total_steps, "Obtaining SSL certificate")
+                self._obtain_certificate()
 
             self.logger.step(8, total_steps, "Creating systemd service")
             self._create_systemd_service()
@@ -273,7 +294,10 @@ class DockerComposeDeployer:
             self.logger.key_value("Path", str(self.app_path))
             self.logger.key_value("Compose File", str(self.compose_path.name))
             self.logger.key_value("Services", str(len(self.services)))
-            self.logger.key_value("SSL", "Yes" if self.ssl else "No")
+            if headless:
+                self.logger.key_value("Mode", "Headless worker (no web server)")
+            else:
+                self.logger.key_value("SSL", "Yes" if self.ssl else "No")
 
         except Exception as e:
             self.logger.error(f"Deployment failed: {e}")
@@ -285,7 +309,7 @@ class DockerComposeDeployer:
         source_manager = SourceManager(verbose=self.verbose)
         source_manager.fetch(
             source=self.source,
-            target=self.app_path,
+            destination=self.app_path,
             branch=self.branch,
         )
         self.logger.substep(f"Source fetched to {self.app_path}")
@@ -407,7 +431,7 @@ class DockerComposeDeployer:
         if no_cache:
             cmd.append("--no-cache")
 
-        result = run_command(cmd, cwd=self.app_path, timeout=600000)
+        result = run_command(cmd, cwd=self.app_path, timeout=600)
         if not result.success:
             raise DockerError(
                 "Failed to build Docker images",
@@ -561,14 +585,11 @@ class DockerComposeDeployer:
 
         service_manager.create_service(
             name=self.app_name,
+            working_directory=str(self.app_path),
+            description=f"Docker Compose app: {self.domain}",
+            environment=service_env,
             template="docker-compose",
-            context={
-                "name": self.app_name,
-                "description": f"Docker Compose app: {self.domain}",
-                "working_directory": str(self.app_path),
-                "environment": service_env,
-                "compose_file": compose_file_rel,
-            },
+            compose_file=compose_file_rel,
         )
         self.logger.substep(f"Created systemd service: {self.app_name}")
 
@@ -638,7 +659,8 @@ class DockerComposeDeployer:
 
     def _register_app(self) -> None:
         """Register the application in the WASM store."""
-        primary_port = self._get_primary_port()
+        headless = self._is_headless()
+        primary_port = 0 if headless else self._get_primary_port()
 
         app = App(
             domain=self.domain,
@@ -647,7 +669,7 @@ class DockerComposeDeployer:
             branch=self.branch,
             port=primary_port,
             app_path=str(self.app_path),
-            webserver=self.webserver,
+            webserver="" if headless else self.webserver,
             ssl_enabled=self.ssl,
             status=AppStatus.RUNNING.value,
             env_vars=self.env_vars,
@@ -676,14 +698,15 @@ class DockerComposeDeployer:
         except Exception:
             pass
 
-        # Remove nginx config
-        try:
-            nginx = NginxManager(verbose=self.verbose)
-            if nginx.site_exists(self.domain):
-                nginx.delete_site(self.domain)
-                nginx.reload()
-        except Exception:
-            pass
+        # Remove nginx config (only if web-facing)
+        if not self._is_headless():
+            try:
+                nginx = NginxManager(verbose=self.verbose)
+                if nginx.site_exists(self.domain):
+                    nginx.delete_site(self.domain)
+                    nginx.reload()
+            except Exception:
+                pass
 
         # Remove app directory
         if self.app_path.exists():
@@ -791,7 +814,7 @@ class DockerComposeDeployer:
             cmd.extend(["-f", str(self.compose_path)])
         cmd.extend(["up", "-d", "--remove-orphans"])
 
-        result = run_command(cmd, cwd=self.app_path, timeout=300000)
+        result = run_command(cmd, cwd=self.app_path, timeout=300)
         if not result.success:
             raise DockerError("Failed to update containers", result.stderr)
 

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/deployers/helpers/env_manager.py

@@ -113,7 +113,7 @@ class EnvManager:
 
     # Secret detection patterns
     SECRET_PATTERNS = [
-        "PASSWORD", "SECRET", "TOKEN", "API_KEY", "PRIVATE_KEY",
+        "PASSWORD", "_PASS", "SECRET", "TOKEN", "API_KEY", "PRIVATE_KEY",
         "ENCRYPTION_KEY", "SIGNING_KEY", "ACCESS_KEY", "SECRET_KEY",
         "CLIENT_SECRET", "WEBHOOK_SECRET",
     ]

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/managers/cert_manager.py

@@ -155,10 +155,11 @@ class CertManager(BaseManager):
         apache: bool = False,
         dry_run: bool = False,
         additional_domains: Optional[List[str]] = None,
+        expand: bool = False,
     ) -> bool:
         """
         Obtain a new certificate.
-        
+
         Args:
             domain: Primary domain name.
             email: Email for registration and recovery.
@@ -168,16 +169,19 @@ class CertManager(BaseManager):
             apache: Use apache plugin.
             dry_run: Test certificate issuance.
             additional_domains: Additional domains for the certificate.
-            
+            expand: Expand existing certificate to include additional domains.
+
         Returns:
             True if certificate was obtained successfully.
-            
+
         Raises:
             CertificateError: If certificate issuance fails.
         """
         if self.cert_exists(domain) and not dry_run:
-            self.logger.warning(f"Certificate already exists for {domain}")
-            return True
+            if not expand or not additional_domains:
+                self.logger.warning(f"Certificate already exists for {domain}")
+                return True
+            self.logger.info(f"Expanding certificate for {domain}")
         
         # Build command
         cmd = ["certbot", "certonly"]
@@ -244,6 +248,10 @@ class CertManager(BaseManager):
             for d in additional_domains:
                 cmd.extend(["-d", d])
         
+        # Expand existing certificate
+        if expand and self.cert_exists(domain):
+            cmd.append("--expand")
+
         # Dry run
         if dry_run:
             cmd.append("--dry-run")

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/managers/service_manager.py

@@ -238,41 +238,43 @@ class ServiceManager(BaseManager):
     def create_service(
         self,
         name: str,
-        command: str,
-        working_directory: str,
+        command: str = "",
+        working_directory: str = "",
         user: Optional[str] = None,
         group: Optional[str] = None,
         environment: Optional[Dict[str, str]] = None,
         description: Optional[str] = None,
         template: str = "app",
+        **kwargs,
     ) -> bool:
         """
         Create a new systemd service.
-        
+
         Args:
             name: Service name.
-            command: Command to execute.
+            command: Command to execute (not required for docker-compose template).
             working_directory: Working directory for the service.
             user: User to run service as.
             group: Group to run service as.
             environment: Environment variables.
             description: Service description.
             template: Template name.
-            
+            **kwargs: Extra context variables passed to the template.
+
         Returns:
             True if service was created successfully.
-            
+
         Raises:
             ServiceError: If creation fails.
         """
         service_name = self._get_service_name(name)
-        
+
         if self.service_exists(name):
             raise ServiceError(f"Service already exists: {service_name}")
-        
+
         if not self.jinja_env:
             raise ServiceError("Template environment not initialized")
-        
+
         # Prepare context
         ctx = {
             "name": service_name,
@@ -283,6 +285,7 @@ class ServiceManager(BaseManager):
             "group": group or self.config.service_group,
             "environment": environment or {},
         }
+        ctx.update(kwargs)
         
         # Render template
         try:

{wasm_cli-0.15.2 → wasm_cli-0.15.4}/src/wasm/templates/apache/proxy.conf.j2

@@ -3,6 +3,9 @@
 
 <VirtualHost *:80>
     ServerName {{ domain }}
+{% if server_names is defined and server_names != domain %}
+    ServerAlias www.{{ domain }}
+{% endif %}
     ServerAdmin webmaster@{{ domain }}
 
 {% if ssl %}
@@ -14,6 +17,9 @@
 
 <VirtualHost *:443>
     ServerName {{ domain }}
+{% if server_names is defined and server_names != domain %}
+    ServerAlias www.{{ domain }}
+{% endif %}
     ServerAdmin webmaster@{{ domain }}
 
     # SSL Configuration