wasm-cli 0.14.4__tar.gz → 0.15.1__tar.gz

{wasm_cli-0.14.4/src/wasm_cli.egg-info → wasm_cli-0.15.1}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wasm-cli"
-version = "0.14.4"
+version = "0.15.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.4 → wasm_cli-0.15.1}/setup.py

@@ -9,7 +9,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="wasm-cli",
-    version="0.14.4",
+    version="0.15.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",
@@ -24,10 +24,33 @@ setup(
     ],
     extras_require={
         "interactive": ["inquirer>=3.1.0"],
+        "web": [
+            "fastapi>=0.109.0",
+            "uvicorn[standard]>=0.27.0",
+            "python-jose[cryptography]>=3.3.0",
+            "passlib[bcrypt]>=1.7.4",
+            "psutil>=5.9.0",
+            "aiofiles>=23.0.0",
+        ],
+        "monitor": [
+            "psutil>=5.9.0",
+            "httpx>=0.25.0",
+        ],
+        "all": [
+            "inquirer>=3.1.0",
+            "rich>=13.0",
+            "psutil>=5.9.0",
+            "httpx>=0.25.0",
+            "fastapi>=0.109.0",
+            "uvicorn[standard]>=0.27.0",
+            "python-jose[cryptography]>=3.3.0",
+            "passlib[bcrypt]>=1.7.4",
+            "aiofiles>=23.0.0",
+        ],
     },
     entry_points={
         "console_scripts": [
-            "wasm=wasm.main:main",
+            "wasm=wasm.main:cli",
         ],
     },
     data_files=[

{wasm_cli-0.14.4 → wasm_cli-0.15.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.4"
+__version__ = "0.15.1"
 __author__ = "Yago López Prado"
 __license__ = "WASM-NCSAL"
 

{wasm_cli-0.14.4 → wasm_cli-0.15.1}/src/wasm/cli/commands/backup.py

@@ -29,6 +29,8 @@ def handle_backup(args: Namespace) -> int:
         return _backup_info(args, verbose)
     elif action == "storage":
         return _backup_storage(args, verbose)
+    elif action == "schedule":
+        return _backup_schedule(args, verbose)
     else:
         logger = Logger(verbose=verbose)
         logger.error(f"Unknown backup action: {action}")
@@ -480,9 +482,120 @@ def _backup_storage(args: Namespace, verbose: bool) -> int:
                 app_str = f"{app_bytes:.1f} TB"
             
             logger.info(f"  {app_name}: {app_str} ({app_usage['count']} backups)")
-        
+
         return 0
-        
+
     except Exception as e:
         logger.error(f"Error: {e}")
         return 1
+
+
+def _backup_schedule(args: Namespace, verbose: bool) -> int:
+    """Handle backup schedule subcommands."""
+    logger = Logger(verbose=verbose)
+    schedule_action = getattr(args, "schedule_action", None)
+
+    if not schedule_action:
+        logger.error("Schedule requires an action: create, list, or delete")
+        return 1
+
+    if schedule_action == "create":
+        return _backup_schedule_create(args, verbose)
+    elif schedule_action in ("list", "ls"):
+        return _backup_schedule_list(args, verbose)
+    elif schedule_action in ("delete", "remove", "rm"):
+        return _backup_schedule_delete(args, verbose)
+    else:
+        logger.error(f"Unknown schedule action: {schedule_action}")
+        return 1
+
+
+def _backup_schedule_create(args: Namespace, verbose: bool) -> int:
+    """Create a backup schedule."""
+    logger = Logger(verbose=verbose)
+
+    domain = getattr(args, "domain", None)
+    schedule = getattr(args, "schedule", "daily")
+    retention_count = getattr(args, "retention_count", 7)
+    retention_days = getattr(args, "retention_days", 30)
+
+    if not domain:
+        logger.error("Domain is required")
+        return 1
+
+    try:
+        from wasm.managers.backup_scheduler import BackupScheduler, BackupSchedule
+        from wasm.core.utils import domain_to_app_name
+
+        scheduler = BackupScheduler(verbose=verbose)
+        backup_schedule = BackupSchedule(
+            domain=domain,
+            app_name=domain_to_app_name(domain),
+            schedule=schedule,
+            retention_count=retention_count,
+            retention_days=retention_days,
+        )
+
+        scheduler.create_schedule(backup_schedule)
+        logger.success(f"Backup schedule created for {domain}")
+        logger.info(f"  Schedule: {backup_schedule.on_calendar}")
+        logger.info(f"  Retention: {retention_count} backups / {retention_days} days")
+        return 0
+
+    except Exception as e:
+        logger.error(f"Failed to create schedule: {e}")
+        if verbose:
+            import traceback
+            traceback.print_exc()
+        return 1
+
+
+def _backup_schedule_list(args: Namespace, verbose: bool) -> int:
+    """List backup schedules."""
+    logger = Logger(verbose=verbose)
+
+    try:
+        from wasm.managers.backup_scheduler import BackupScheduler
+
+        scheduler = BackupScheduler(verbose=verbose)
+        schedules = scheduler.list_schedules()
+
+        if not schedules:
+            logger.info("No backup schedules found")
+            return 0
+
+        logger.header("Backup Schedules")
+        for sched in schedules:
+            logger.info(
+                f"  {sched['app_name']}: "
+                f"next={sched.get('next_run', '?')} "
+                f"last={sched.get('last_run', 'never')}"
+            )
+
+        return 0
+
+    except Exception as e:
+        logger.error(f"Failed to list schedules: {e}")
+        return 1
+
+
+def _backup_schedule_delete(args: Namespace, verbose: bool) -> int:
+    """Delete a backup schedule."""
+    logger = Logger(verbose=verbose)
+
+    domain = getattr(args, "domain", None)
+    if not domain:
+        logger.error("Domain is required")
+        return 1
+
+    try:
+        from wasm.managers.backup_scheduler import BackupScheduler
+
+        scheduler = BackupScheduler(verbose=verbose)
+        scheduler.remove_schedule(domain)
+        logger.success(f"Backup schedule removed for {domain}")
+        return 0
+
+    except Exception as e:
+        logger.error(f"Failed to remove schedule: {e}")
+        return 1

wasm_cli-0.15.1/src/wasm/cli/commands/env.py

@@ -0,0 +1,220 @@
+# 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
+
+"""
+Environment variable CLI commands for WASM.
+
+Provides CLI handlers for managing application environment variables:
+- Interactive configuration from .env.example templates
+- Viewing current values with secret masking
+- Exporting variables to files
+"""
+
+import sys
+from argparse import Namespace
+from pathlib import Path
+
+from wasm.core.config import Config
+from wasm.core.logger import Logger
+from wasm.core.exceptions import WASMError
+from wasm.core.utils import domain_to_app_name
+from wasm.deployers.helpers.env_manager import EnvManager, EnvConfig
+
+
+def handle_env(args: Namespace) -> int:
+    """
+    Handle wasm env <action> commands.
+
+    Routes to the appropriate sub-handler based on the action.
+
+    Args:
+        args: Parsed command-line arguments.
+
+    Returns:
+        Exit code (0 for success, non-zero for error).
+    """
+    action = getattr(args, "action", None)
+    verbose = getattr(args, "verbose", False)
+
+    if not action:
+        print("Error: env requires an action", file=sys.stderr)
+        print("Use: wasm env --help", file=sys.stderr)
+        return 1
+
+    handlers = {
+        "configure": _env_configure,
+        "config": _env_configure,
+        "setup": _env_configure,
+        "show": _env_show,
+        "list": _env_show,
+        "ls": _env_show,
+        "export": _env_export,
+    }
+
+    handler = handlers.get(action)
+    if not handler:
+        print(f"Unknown env action: {action}", file=sys.stderr)
+        return 1
+
+    try:
+        return handler(args, verbose)
+    except WASMError as e:
+        logger = Logger(verbose=verbose)
+        logger.error(e.message)
+        if e.details:
+            print(f"  {e.details}")
+        return 1
+
+
+def _env_configure(args: Namespace, verbose: bool) -> int:
+    """
+    Run interactive environment configuration.
+
+    Discovers variables from .env.example files, prompts the user
+    for values, auto-generates secrets, and writes .env files.
+
+    Args:
+        args: Parsed arguments (requires domain).
+        verbose: Whether to enable verbose output.
+
+    Returns:
+        Exit code.
+    """
+    logger = Logger(verbose=verbose)
+    config = Config()
+
+    domain = getattr(args, "domain", None)
+    if not domain:
+        logger.error("Domain is required")
+        return 1
+
+    app_name = domain_to_app_name(domain)
+    app_path = config.apps_directory / app_name
+
+    if not app_path.exists():
+        logger.error(f"Application not found: {domain}")
+        return 1
+
+    manager = EnvManager(verbose=verbose)
+
+    logger.header(f"Environment Configuration: {domain}")
+
+    # Discover variables
+    variables = manager.discover(app_path)
+    if not variables:
+        logger.info("No .env.example files found")
+        return 0
+
+    logger.info(f"Found {len(variables)} variables")
+
+    # Load existing values
+    existing = manager.get_current_values(app_path)
+
+    # Prompt for values
+    values = manager.prompt_variables(variables, existing)
+
+    # Write .env file
+    written = manager.write_env_files(app_path, values)
+    for path in written:
+        logger.success(f"Written: {path}")
+
+    # Save config
+    env_config = EnvConfig(variables=variables)
+    manager.save_config(app_path, env_config)
+
+    return 0
+
+
+def _env_show(args: Namespace, verbose: bool) -> int:
+    """
+    Display current environment variables.
+
+    Shows all variables from the application's .env file, with
+    secret values masked by default.
+
+    Args:
+        args: Parsed arguments (requires domain, optional --unmask).
+        verbose: Whether to enable verbose output.
+
+    Returns:
+        Exit code.
+    """
+    logger = Logger(verbose=verbose)
+    config = Config()
+
+    domain = getattr(args, "domain", None)
+    if not domain:
+        logger.error("Domain is required")
+        return 1
+
+    unmask = getattr(args, "unmask", False)
+
+    app_name = domain_to_app_name(domain)
+    app_path = config.apps_directory / app_name
+
+    if not app_path.exists():
+        logger.error(f"Application not found: {domain}")
+        return 1
+
+    manager = EnvManager(verbose=verbose)
+    values = manager.get_current_values(app_path)
+
+    if not values:
+        logger.info(f"No environment variables found for {domain}")
+        return 0
+
+    logger.header(f"Environment: {domain}")
+
+    for key in sorted(values.keys()):
+        value = values[key]
+        if not unmask:
+            value = manager.mask_value(key, value)
+        logger.key_value(f"  {key}", value)
+
+    return 0
+
+
+def _env_export(args: Namespace, verbose: bool) -> int:
+    """
+    Export environment variables to a file.
+
+    Reads the application's .env file and writes it to the
+    specified output path.
+
+    Args:
+        args: Parsed arguments (requires domain, optional --output).
+        verbose: Whether to enable verbose output.
+
+    Returns:
+        Exit code.
+    """
+    logger = Logger(verbose=verbose)
+    config = Config()
+
+    domain = getattr(args, "domain", None)
+    output = getattr(args, "output", ".env")
+
+    if not domain:
+        logger.error("Domain is required")
+        return 1
+
+    app_name = domain_to_app_name(domain)
+    app_path = config.apps_directory / app_name
+
+    if not app_path.exists():
+        logger.error(f"Application not found: {domain}")
+        return 1
+
+    manager = EnvManager(verbose=verbose)
+    values = manager.get_current_values(app_path)
+
+    if not values:
+        logger.info(f"No environment variables found for {domain}")
+        return 0
+
+    output_path = Path(output)
+    manager._write_single_env_file(output_path, values)
+    logger.success(f"Exported {len(values)} variables to {output_path}")
+
+    return 0

{wasm_cli-0.14.4 → wasm_cli-0.15.1}/src/wasm/cli/commands/webapp.py

@@ -207,6 +207,10 @@ def _handle_create(args: Namespace) -> int:
     if app_type == "monorepo":
         return _handle_monorepo_create(args, domain, env_vars, logger)
 
+    # Handle docker-compose deployments specially
+    if app_type == "docker-compose":
+        return _handle_docker_compose_create(args, domain, env_vars, logger)
+
     # Get deployer
     deployer = get_deployer(app_type, verbose=args.verbose)
 
@@ -269,6 +273,31 @@ def _handle_monorepo_create(args: Namespace, domain: str, env_vars: Dict, logger
     return 0
 
 
+def _handle_docker_compose_create(
+    args: Namespace, domain: str, env_vars: Dict, logger: Logger
+) -> int:
+    """Handle Docker Compose deployment."""
+    from wasm.deployers.docker_compose import DockerComposeDeployer
+
+    deployer = DockerComposeDeployer(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,
+        compose_file=getattr(args, "compose_file", None),
+        compose_profiles=getattr(args, "compose_profiles", None),
+        port=args.port,
+    )
+
+    deployer.deploy()
+
+    return 0
+
+
 def _handle_list(args: Namespace) -> int:
     """Handle webapp list command."""
     logger = Logger(verbose=args.verbose)
@@ -587,12 +616,19 @@ def _handle_update(args: Namespace) -> int:
     
     # Step 3: Detect app type and configure deployer
     logger.step(3, total_steps, "Detecting application type")
-    app_type = detect_app_type(app_path, verbose=args.verbose)
-    if not app_type:
-        app_type = "nodejs"
-        logger.substep(f"Using default: {app_type}")
-    else:
+
+    # Prefer stored app type from database (initial deploy already determined it correctly)
+    stored_type = app.app_type if app else None
+    if stored_type and stored_type != "unknown":
+        app_type = stored_type
         logger.substep(f"Detected: {app_type}")
+    else:
+        app_type = detect_app_type(app_path, verbose=args.verbose)
+        if not app_type:
+            app_type = "nodejs"
+            logger.substep(f"Using default: {app_type}")
+        else:
+            logger.substep(f"Detected: {app_type}")
     
     # Handle monorepo updates with dedicated flow
     if app_type == "monorepo":
@@ -600,6 +636,12 @@ def _handle_update(args: Namespace) -> int:
             args, app_path, app_name, domain, logger, total_steps
         )
 
+    # Handle docker-compose updates
+    if app_type == "docker-compose":
+        return _handle_docker_compose_update(
+            args, app_path, app_name, domain, logger
+        )
+
     deployer = get_deployer(app_type, verbose=args.verbose)
     deployer.app_path = app_path
     deployer.app_name = app_name
@@ -734,6 +776,38 @@ def _handle_monorepo_update(args, app_path, app_name, domain, logger, total_step
     return 0
 
 
+def _handle_docker_compose_update(args, app_path, app_name, domain, logger):
+    """Handle update for Docker Compose applications."""
+    from wasm.deployers.docker_compose import DockerComposeDeployer
+
+    deployer = DockerComposeDeployer(verbose=args.verbose)
+    deployer.app_path = app_path
+    deployer.app_name = app_name
+    deployer.domain = domain
+
+    # Discover compose file
+    deployer._discover_compose_file()
+
+    logger.step(4, 5, "Rebuilding Docker images")
+    deployer._build_images()
+
+    logger.step(5, 5, "Restarting containers")
+    from wasm.core.utils import run_command
+    cmd = ["docker", "compose"]
+    if deployer.compose_path:
+        cmd.extend(["-f", str(deployer.compose_path)])
+    cmd.extend(["up", "-d", "--remove-orphans"])
+    result = run_command(cmd, cwd=app_path, timeout=300000)
+
+    if result.success:
+        logger.success(f"Docker Compose app updated: {domain}")
+    else:
+        logger.warning("Update may have issues. Check with: docker compose ps")
+        logger.warning(result.stderr)
+
+    return 0
+
+
 def _handle_delete(args: Namespace) -> int:
     """Handle webapp delete command."""
     logger = Logger(verbose=args.verbose)
@@ -807,8 +881,22 @@ def _handle_delete(args: Namespace) -> int:
 
     total_steps = 5
 
-    # Stop and delete service
-    logger.step(1, total_steps, "Stopping service")
+    # Stop Docker Compose containers if applicable
+    if app and app.app_type == "docker-compose":
+        logger.step(1, total_steps, "Stopping Docker Compose containers")
+        from wasm.core.utils import run_command as _run_cmd
+        for compose_name in ["docker-compose.prod.yml", "docker-compose.yml", "compose.yml"]:
+            compose_file = app_path / compose_name
+            if compose_file.exists():
+                _run_cmd(
+                    ["docker", "compose", "-f", str(compose_file), "down", "--remove-orphans"],
+                    cwd=app_path,
+                )
+                break
+    else:
+        logger.step(1, total_steps, "Stopping service")
+
+    # Delete systemd service
     service_manager = ServiceManager(verbose=args.verbose)
     try:
         service_manager.delete_service(app_name)
@@ -858,10 +946,45 @@ def _handle_logs(args: Namespace) -> int:
     """Handle webapp logs command."""
     logger = Logger(verbose=args.verbose)
     service_manager = ServiceManager(verbose=args.verbose)
-    
+
     domain = validate_domain(args.domain)
     app_name = domain_to_app_name(domain)
-    
+
+    # Check if this is a docker-compose app
+    from wasm.core.store import get_store
+    store = get_store()
+    app = store.get_app(domain)
+
+    if app and app.app_type == "docker-compose":
+        config = Config()
+        app_path = Path(app.app_path) if app.app_path else config.apps_directory / app_name
+        from wasm.core.utils import run_command as _run_cmd
+        import subprocess
+
+        # Find compose file
+        compose_file = None
+        for name in ["docker-compose.prod.yml", "docker-compose.yml", "compose.yml"]:
+            cf = app_path / name
+            if cf.exists():
+                compose_file = str(cf)
+                break
+
+        cmd = ["docker", "compose"]
+        if compose_file:
+            cmd.extend(["-f", compose_file])
+        cmd.extend(["logs", "--tail", str(args.lines)])
+
+        if args.follow:
+            cmd.append("-f")
+            try:
+                subprocess.run(cmd, cwd=app_path)
+            except KeyboardInterrupt:
+                pass
+        else:
+            result = _run_cmd(cmd, cwd=app_path)
+            print(result.stdout if result.success else result.stderr)
+        return 0
+
     # Get resolved service name (handles both legacy wasm-* and new format)
     service_name = service_manager._resolve_service_name(app_name)