rocketdoo 2.2.3__tar.gz → 2.3.0__tar.gz

{rocketdoo-2.2.3 → rocketdoo-2.3.0}/LICENSE

@@ -57,7 +57,7 @@ If the Library as you received it specifies that a proxy can decide whether futu
 <div RKD as ROCKETDOO V2=""></div>
 
 Licencia: LGPL-3.0+
-Versión: "2.2.3"
+Versión: "2.3.0"
 Autor: Horacio Montaño, Elias Braceras
 Fecha: 16/10/2024
 Descripción: Framework to development Odoo

{rocketdoo-2.2.3/rocketdoo.egg-info → rocketdoo-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocketdoo
-Version: 2.2.3
+Version: 2.3.0
 Summary: Framework for creating Odoo development environments with Docker and custom templates.
 Author-email: Horacio Montaño <horaciomontano@hdmsoft.com.ar>
 License: GNU LESSER GENERAL PUBLIC LICENSE
@@ -62,7 +62,7 @@ License: GNU LESSER GENERAL PUBLIC LICENSE
         <div RKD as ROCKETDOO V2=""></div>
         
         Licencia: LGPL-3.0+
-        Versión: "2.2.3"
+        Versión: "2.3.0"
         Autor: Horacio Montaño, Elias Braceras
         Fecha: 16/10/2024
         Descripción: Framework to development Odoo
@@ -95,7 +95,7 @@ Odoo Development Framework
    - "Horacio Montaño" and "Elias Braceras"
 
 ## Version: 
-   - "2.2.3"
+   - "2.3.0"
 
 ----------------------------------------------------------------------------------------------------------------------------------------------------------
 

{rocketdoo-2.2.3 → rocketdoo-2.3.0}/README.md

@@ -15,7 +15,7 @@ Odoo Development Framework
    - "Horacio Montaño" and "Elias Braceras"
 
 ## Version: 
-   - "2.2.3"
+   - "2.3.0"
 
 ----------------------------------------------------------------------------------------------------------------------------------------------------------
 

{rocketdoo-2.2.3 → rocketdoo-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rocketdoo"
-version = "2.2.3"
+version = "2.3.0"
 description = "Framework for creating Odoo development environments with Docker and custom templates."
 authors = [
     { name = "Horacio Montaño", email = "horaciomontano@hdmsoft.com.ar" }

{rocketdoo-2.2.3 → rocketdoo-2.3.0}/rocketdoo/cli.py

@@ -19,6 +19,8 @@ from rocketdoo.deploy_cli import (
     deploy_run, 
     validate_modules
 )
+from rocketdoo.pack_environment import pack_environment
+from rocketdoo.unpack_environment import unpack_environment
 
 # Detect the command name used to invoke the CLI
 PROG_NAME = "rkd" if "rkd" in sys.argv[0] else "rocketdoo"
@@ -425,6 +427,12 @@ main.add_command(logs)
 main.add_command(build)
 main.add_command(delete_command)
 
+# ============================================================
+# 📦 Register Share/Unpack commands
+# ============================================================
+main.add_command(pack_environment, name="pack")
+main.add_command(unpack_environment, name="unpack")
+
 # ============================================================
 # 🚀 Register Deploy commands as Rocketdoo subcommands
 # ============================================================

{rocketdoo-2.2.3 → rocketdoo-2.3.0}/rocketdoo/core/deploy/vps.py

@@ -179,6 +179,7 @@ class VPSDeployer(BaseDeployer):
         - SSH connectivity
         - Remote paths exist
         - Required commands available
+        - Sudo permissions (if needed)
         
         Returns:
             True if all checks pass
@@ -194,6 +195,29 @@ class VPSDeployer(BaseDeployer):
             
             self.log("✓ SSH connection established", "success")
             
+            # Check sudo permissions if using native deployment with restart enabled
+            if (self.deployment_type == 'native' and 
+                self.post_deploy_config.get('restart_service', False)):
+                self.log("Checking sudo permissions...", "info")
+                
+                # Test sudo without password (passwordless sudo)
+                result = self._run_ssh_command("sudo -n true 2>&1")
+                
+                if result.returncode != 0:
+                    if self.auth_method == 'password':
+                        self.log("✓ Sudo requires password (will use authentication password)", "info")
+                    else:
+                        self.log(
+                            "⚠️  Sudo requires password but SSH key authentication is used.\n"
+                            "   Configure passwordless sudo for service restart or disable 'restart_service'.\n"
+                            "   Run on server: sudo visudo\n"
+                            f"   Add: {self.user} ALL=(ALL) NOPASSWD: /bin/systemctl restart {self.service_name}",
+                            "warning"
+                        )
+                        # Don't fail, just warn
+                else:
+                    self.log("✓ Passwordless sudo available", "success")
+            
             # Check if remote path exists
             if self.deployment_type == 'docker':
                 remote_path = f"{self.compose_path}"
@@ -206,7 +230,7 @@ class VPSDeployer(BaseDeployer):
                 self.log(f"Warning: Remote path {remote_path} does not exist", "warning")
                 # Try to create it
                 self.log(f"Attempting to create {remote_path}...", "info")
-                create_result = self._run_ssh_command(f"sudo mkdir -p {remote_path}")
+                create_result = self._run_ssh_command(f"sudo mkdir -p {remote_path}", use_sudo=True)
                 if create_result.returncode != 0:
                     self.log(f"Failed to create remote path: {create_result.stderr}", "error")
                     return False
@@ -268,7 +292,6 @@ class VPSDeployer(BaseDeployer):
                     local_path = temp_dir / module_name
                     remote_module_path = f"{target_path}/{module_name}"
                     
-                    # ✅ SIMPLIFICADO: Siempre actualiza (rsync con --delete ya hace esto)
                     # Upload module
                     success = self._upload_directory(local_path, remote_module_path)
                     
@@ -332,9 +355,10 @@ class VPSDeployer(BaseDeployer):
                             message="Failed to restart Docker container"
                         )
                 else:
-                    # Restart systemd service
+                    # Restart systemd service with sudo (handles password if needed)
                     result = self._run_ssh_command(
-                        f"sudo systemctl restart {self.service_name}"
+                        f"systemctl restart {self.service_name}",
+                        use_sudo=True
                     )
                     
                     if result.returncode != 0:
@@ -397,17 +421,27 @@ class VPSDeployer(BaseDeployer):
                 message=f"Post-deploy error: {e}"
             )
     
-    def _run_ssh_command(self, command: str, timeout: int = 300) -> subprocess.CompletedProcess:
+    def _run_ssh_command(self, command: str, timeout: int = 300, use_sudo: bool = False) -> subprocess.CompletedProcess:
         """
         Execute command on remote server via SSH
         
         Args:
             command: Command to execute
             timeout: Command timeout in seconds
+            use_sudo: If True, prepend sudo to command and handle password if needed
             
         Returns:
             CompletedProcess with result
         """
+        # Handle sudo with password authentication
+        if use_sudo:
+            if self.auth_method == 'password' and self.password:
+                # Use echo password | sudo -S for password-based sudo
+                command = f"echo '{self.password}' | sudo -S {command}"
+            else:
+                # Try passwordless sudo or rely on SSH key having sudo access
+                command = f"sudo {command}"
+        
         ssh_cmd = ['ssh']
         
         # Add SSH options
@@ -606,7 +640,7 @@ class VPSDeployer(BaseDeployer):
             if self.deployment_type == 'docker':
                 self._run_ssh_command(f"cd {self.compose_path} && docker-compose restart {self.container_name}")
             else:
-                self._run_ssh_command(f"sudo systemctl restart {self.service_name}")
+                self._run_ssh_command(f"systemctl restart {self.service_name}", use_sudo=True)
             
             self.log("✓ Rollback completed", "success")
             

rocketdoo-2.3.0/rocketdoo/pack_environment.py

@@ -0,0 +1,429 @@
+# rocketdoo/pack_environment.py
+"""
+rkd pack — Packages the development environment to share with another developer.
+
+Steps:
+  1. Validates that a Rocketdoo project exists in the current directory.
+  2. Backs up the active database + filestore via pg_dump inside the container.
+  3. Sanitizes the Dockerfile: comments out SSH key lines to avoid exposing them.
+  4. Excludes the .ssh/ directory from the ZIP (must never be shared).
+  5. Creates rkd-shared.json with environment metadata (flags private repo usage).
+  6. Compresses everything into a shareable ZIP file.
+  7. Restores the original Dockerfile after compression.
+"""
+
+import re
+import json
+import subprocess
+import zipfile
+from datetime import datetime
+from pathlib import Path
+
+import click
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+from rich import box
+
+from rocketdoo.project_info import get_project_info, project_exists, read_docker_compose
+
+console = Console()
+
+# ─────────────────────────────────────────────────────────────
+# Internal helpers
+# ─────────────────────────────────────────────────────────────
+
+def _get_db_container(compose_data: dict) -> str | None:
+    """Returns the database container name from docker-compose data."""
+    try:
+        return compose_data["services"]["db"]["container_name"]
+    except (KeyError, TypeError):
+        return None
+
+
+def _get_odoo_container(compose_data: dict) -> str | None:
+    """Returns the Odoo web container name from docker-compose data."""
+    try:
+        return compose_data["services"]["web"]["container_name"]
+    except (KeyError, TypeError):
+        return None
+
+
+def _is_container_running(container_name: str) -> bool:
+    """Checks whether a Docker container is currently running."""
+    try:
+        result = subprocess.run(
+            ["docker", "inspect", "--format", "{{.State.Running}}", container_name],
+            capture_output=True, text=True
+        )
+        return result.stdout.strip() == "true"
+    except Exception:
+        return False
+
+
+def _list_odoo_databases(db_container: str) -> list[str]:
+    """Lists available databases in the PostgreSQL container."""
+    try:
+        result = subprocess.run(
+            [
+                "docker", "exec", db_container,
+                "psql", "-U", "root", "-d", "postgres",
+                "-t", "-c",
+                "SELECT datname FROM pg_database WHERE datistemplate = false AND datname != 'postgres';"
+            ],
+            capture_output=True, text=True
+        )
+        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+    except Exception:
+        return []
+
+
+def _backup_database(db_container: str, db_name: str, output_path: Path) -> bool:
+    """
+    Runs pg_dump inside the container and saves the result to output_path.
+    Returns True if the backup succeeded.
+    """
+    console.print(f"  [dim]Running pg_dump for '[cyan]{db_name}[/cyan]'...[/dim]")
+    try:
+        with open(output_path, "wb") as f:
+            result = subprocess.run(
+                [
+                    "docker", "exec", db_container,
+                    "pg_dump", "-U", "root", "--format=custom", db_name
+                ],
+                stdout=f,
+                stderr=subprocess.PIPE
+            )
+        if result.returncode != 0:
+            console.print(f"  [red]✗ pg_dump error:[/red] {result.stderr.decode()}")
+            return False
+        size_mb = output_path.stat().st_size / (1024 * 1024)
+        console.print(f"  [green]✓[/green] Backup saved: [yellow]{output_path.name}[/yellow] ({size_mb:.1f} MB)")
+        return True
+    except Exception as e:
+        console.print(f"  [red]✗ Exception during database backup:[/red] {e}")
+        return False
+
+
+def _backup_filestore(odoo_container: str, db_name: str, output_path: Path) -> bool:
+    """
+    Copies and compresses the Odoo filestore from the container to the host.
+    Filestore path inside container: /var/lib/odoo/.local/share/Odoo/filestore/<db_name>/
+    """
+    filestore_path = f"/var/lib/odoo/.local/share/Odoo/filestore/{db_name}"
+    console.print(f"  [dim]Copying filestore from container...[/dim]")
+    try:
+        check = subprocess.run(
+            ["docker", "exec", odoo_container, "test", "-d", filestore_path],
+            capture_output=True
+        )
+        if check.returncode != 0:
+            console.print(f"  [yellow]⚠[/yellow]  Filestore not found at [dim]{filestore_path}[/dim] — skipping.")
+            return True  # Not a fatal error
+
+        with open(output_path, "wb") as f:
+            result = subprocess.run(
+                [
+                    "docker", "exec", odoo_container,
+                    "tar", "-czf", "-", "-C",
+                    "/var/lib/odoo/.local/share/Odoo/filestore/",
+                    db_name
+                ],
+                stdout=f,
+                stderr=subprocess.PIPE
+            )
+        if result.returncode != 0:
+            console.print(f"  [red]✗ Error copying filestore:[/red] {result.stderr.decode()}")
+            return False
+
+        size_mb = output_path.stat().st_size / (1024 * 1024)
+        console.print(f"  [green]✓[/green] Filestore compressed: [yellow]{output_path.name}[/yellow] ({size_mb:.1f} MB)")
+        return True
+    except Exception as e:
+        console.print(f"  [red]✗ Exception during filestore backup:[/red] {e}")
+        return False
+
+
+def _sanitize_dockerfile(dockerfile_path: Path) -> str:
+    """
+    Reads the Dockerfile, comments out all SSH key related lines,
+    and returns the ORIGINAL content so it can be restored afterwards.
+    Writes the sanitized version to disk.
+    """
+    original_content = dockerfile_path.read_text()
+
+    ssh_patterns = [
+        r"^RUN mkdir -p /root/\.ssh",
+        r"^COPY \./.ssh/",
+        r"^RUN chmod \d+ /root/\.ssh/",
+        r"^RUN echo .StrictHostKeyChecking",
+    ]
+
+    sanitized_lines = []
+    for line in original_content.splitlines():
+        stripped = line.strip()
+        is_ssh_line = any(re.match(pat, stripped) for pat in ssh_patterns)
+        if is_ssh_line:
+            sanitized_lines.append(f"# [RKD-SANITIZED] {line}")
+        else:
+            sanitized_lines.append(line)
+
+    dockerfile_path.write_text("\n".join(sanitized_lines))
+    return original_content
+
+
+def _restore_dockerfile(dockerfile_path: Path, original_content: str):
+    """Restores the Dockerfile to its original content."""
+    dockerfile_path.write_text(original_content)
+
+
+def _verify_no_ssh_in_zip(zip_path: Path) -> list[str]:
+    """
+    Safety double-check: scans the ZIP for files that look like private SSH keys.
+    Returns a list of suspicious file names found.
+    """
+    suspicious = []
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        for name in zf.namelist():
+            basename = Path(name).name
+            if any([
+                basename.startswith("id_rsa") and not basename.endswith(".pub"),
+                basename.startswith("id_ed25519") and not basename.endswith(".pub"),
+                basename.startswith("id_ecdsa") and not basename.endswith(".pub"),
+                "/.ssh/" in name and not name.endswith(".pub"),
+            ]):
+                suspicious.append(name)
+    return suspicious
+
+
+def _create_zip(project_dir: Path, zip_path: Path, backup_dir: Path, exclude_dirs: list[str]) -> int:
+    """
+    Creates the ZIP archive of the full environment.
+    Excludes: .ssh/, __pycache__, .git/, node_modules, and any extra dirs provided.
+    Includes the backup directory contents under rkd_backups/.
+    Returns the number of files included.
+    """
+    ALWAYS_EXCLUDE = {".ssh", "__pycache__", ".git", "node_modules", ".mypy_cache"}
+    excluded = ALWAYS_EXCLUDE | set(exclude_dirs)
+
+    file_count = 0
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED, compresslevel=6) as zf:
+        for item in project_dir.rglob("*"):
+            rel = item.relative_to(project_dir)
+            if set(rel.parts) & excluded:
+                continue
+            if item.is_file():
+                zf.write(item, rel)
+                file_count += 1
+
+        if backup_dir.exists() and not backup_dir.is_relative_to(project_dir):
+            for bf in backup_dir.iterdir():
+                if bf.is_file():
+                    zf.write(bf, Path("rkd_backups") / bf.name)
+                    file_count += 1
+
+    return file_count
+
+
+# ─────────────────────────────────────────────────────────────
+# Main command
+# ─────────────────────────────────────────────────────────────
+
+@click.command(name="pack")
+@click.option("--no-db", is_flag=True, default=False,
+              help="Skip the database and filestore backup (environment files only).")
+@click.option("--output", "-o", default=None, type=click.Path(),
+              help="Output path for the ZIP file (default: parent directory, named after the project).")
+@click.option("--db-name", default=None,
+              help="Name of the database to back up (useful when multiple databases exist).")
+def pack_environment(no_db, output, db_name):
+    """
+    📦 Package the development environment to share with another developer.
+
+    Generates a ZIP with the full environment directory, a database backup,
+    and the filestore — sanitizing SSH keys so they are never exposed.
+
+    \b
+    Examples:
+      rkd pack                  → full backup + ZIP
+      rkd pack --no-db          → environment only (no DB backup)
+      rkd pack -o /tmp/my.zip   → specify output path
+    """
+    console.print()
+    console.print(Panel(
+        "[bold cyan]📦 RKD Pack — Prepare environment for sharing[/bold cyan]\n\n"
+        "[dim]This process will:[/dim]\n"
+        "  [green]✓[/green] Back up the database and filestore\n"
+        "  [green]✓[/green] Sanitize SSH keys from the Dockerfile\n"
+        "  [green]✓[/green] Generate a shareable ZIP file",
+        border_style="cyan",
+        box=box.ROUNDED
+    ))
+    console.print()
+
+    # ── 1. Validate project ──
+    if not project_exists():
+        console.print("[red]✗[/red] No Rocketdoo project detected in this directory.")
+        console.print("[dim]💡 Run [cyan]rkd init[/cyan] first.[/dim]")
+        return
+
+    project_dir = Path.cwd()
+    project_info = get_project_info()
+    project_name = project_info.get("project_name") or project_dir.name
+    compose_data = read_docker_compose()
+
+    console.print(f"[bold]Project detected:[/bold] [cyan]{project_name}[/cyan]")
+    console.print(f"[bold]Odoo:[/bold] {project_info.get('odoo_version', 'unknown')} "
+                  f"({project_info.get('odoo_edition', 'Community')})")
+    console.print()
+
+    # ── 2. Database and filestore backup ──
+    backup_dir = project_dir / "rkd_backups"
+    db_backup_path = None
+    fs_backup_path = None
+
+    if not no_db:
+        db_container = _get_db_container(compose_data) if compose_data else None
+        odoo_container = _get_odoo_container(compose_data) if compose_data else None
+
+        if not db_container:
+            console.print("[yellow]⚠[/yellow]  Could not detect the database container.")
+            console.print("[dim]   Continuing without DB backup. Use [cyan]--no-db[/cyan] to suppress this warning.[/dim]")
+        elif not _is_container_running(db_container):
+            console.print(f"[yellow]⚠[/yellow]  Container [cyan]{db_container}[/cyan] is not running.")
+            console.print("[dim]   Start the environment with [cyan]rkd up -d[/cyan] before running pack with backup.[/dim]")
+            if not questionary.confirm("Continue anyway without DB backup?", default=False).ask():
+                console.print("[yellow]Operation cancelled.[/yellow]")
+                return
+        else:
+            console.print("[bold]💾 Database backup:[/bold]")
+            available_dbs = _list_odoo_databases(db_container)
+
+            if not available_dbs:
+                console.print("  [yellow]⚠[/yellow]  No Odoo databases found.")
+            else:
+                if db_name and db_name in available_dbs:
+                    selected_db = db_name
+                elif len(available_dbs) == 1:
+                    selected_db = available_dbs[0]
+                    console.print(f"  Database detected: [cyan]{selected_db}[/cyan]")
+                else:
+                    selected_db = questionary.select(
+                        "Select the database to back up:",
+                        choices=available_dbs
+                    ).ask()
+
+                backup_dir.mkdir(exist_ok=True)
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                db_backup_path = backup_dir / f"db_{selected_db}_{timestamp}.dump"
+                fs_backup_path = backup_dir / f"filestore_{selected_db}_{timestamp}.tar.gz"
+
+                db_ok = _backup_database(db_container, selected_db, db_backup_path)
+                if not db_ok:
+                    db_backup_path = None
+
+                if odoo_container and _is_container_running(odoo_container):
+                    _backup_filestore(odoo_container, selected_db, fs_backup_path)
+                else:
+                    console.print(f"  [yellow]⚠[/yellow]  Odoo container [cyan]{odoo_container}[/cyan] is not running — filestore skipped.")
+                    fs_backup_path = None
+
+    # ── 3. Detect SSH key usage ──
+    uses_ssh = project_info.get("use_private_repos", False)
+    ssh_key_name = project_info.get("ssh_key")
+
+    if uses_ssh:
+        console.print()
+        console.print("[bold]🔐 SSH keys detected:[/bold]")
+        console.print(f"  Key in use: [yellow]{ssh_key_name or 'detected in Dockerfile'}[/yellow]")
+        console.print("  [dim]SSH keys will be excluded from the ZIP.[/dim]")
+
+    # ── 4. Sanitize Dockerfile ──
+    dockerfile_path = project_dir / "Dockerfile"
+    original_dockerfile = None
+
+    if dockerfile_path.exists() and uses_ssh:
+        console.print()
+        console.print("[bold]🧹 Sanitizing Dockerfile...[/bold]")
+        original_dockerfile = _sanitize_dockerfile(dockerfile_path)
+        console.print("  [green]✓[/green] SSH lines commented out in the Dockerfile for the ZIP.")
+
+    # ── 5. Write rkd-shared.json metadata ──
+    shared_meta = {
+        "rkd_shared": True,
+        "packed_at": datetime.now().isoformat(),
+        "project_name": project_name,
+        "odoo_version": project_info.get("odoo_version"),
+        "odoo_edition": project_info.get("odoo_edition", "Community"),
+        "db_version": project_info.get("db_version"),
+        "odoo_port": project_info.get("odoo_port"),
+        "vsc_port": project_info.get("vsc_port"),
+        "uses_private_repos": uses_ssh,
+        "ssh_key_name": ssh_key_name,
+        "has_db_backup": db_backup_path is not None and db_backup_path.exists(),
+        "has_filestore_backup": fs_backup_path is not None and fs_backup_path.exists(),
+    }
+
+    meta_path = project_dir / "rkd-shared.json"
+    meta_path.write_text(json.dumps(shared_meta, indent=2, ensure_ascii=False))
+    console.print()
+    console.print("[dim]📋 Environment metadata written to rkd-shared.json[/dim]")
+
+    # ── 6. Create ZIP ──
+    console.print()
+    console.print("[bold]🗜️  Creating ZIP...[/bold]")
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    if output:
+        zip_path = Path(output)
+    else:
+        zip_path = project_dir.parent / f"{project_name}_rkd_shared_{timestamp}.zip"
+
+    try:
+        file_count = _create_zip(
+            project_dir=project_dir,
+            zip_path=zip_path,
+            backup_dir=backup_dir,
+            exclude_dirs=[".ssh"]
+        )
+    except Exception as e:
+        console.print(f"[red]✗ Error creating ZIP:[/red] {e}")
+        if original_dockerfile:
+            _restore_dockerfile(dockerfile_path, original_dockerfile)
+        meta_path.unlink(missing_ok=True)
+        return
+
+    # ── 7. Restore original Dockerfile ──
+    if original_dockerfile:
+        _restore_dockerfile(dockerfile_path, original_dockerfile)
+        console.print("[dim]  Original Dockerfile restored.[/dim]")
+
+    # Clean up temporary metadata from working directory
+    meta_path.unlink(missing_ok=True)
+
+    # ── 8. SSH safety verification ──
+    suspicious = _verify_no_ssh_in_zip(zip_path)
+    if suspicious:
+        console.print()
+        console.print("[bold red]⚠️  SECURITY WARNING:[/bold red]")
+        console.print("[red]Possible private SSH keys detected inside the ZIP:[/red]")
+        for s in suspicious:
+            console.print(f"  [red]• {s}[/red]")
+        console.print("[dim]Please review the ZIP contents before sharing.[/dim]")
+
+    # ── 9. Final summary ──
+    zip_size_mb = zip_path.stat().st_size / (1024 * 1024)
+    console.print()
+    console.print(Panel(
+        f"[bold green]✅ Environment packaged successfully[/bold green]\n\n"
+        f"[bold]📁 File:[/bold] [cyan]{zip_path}[/cyan]\n"
+        f"[bold]📦 Files included:[/bold] {file_count}\n"
+        f"[bold]💾 Size:[/bold] {zip_size_mb:.1f} MB\n"
+        f"[bold]🔐 SSH Keys:[/bold] {'excluded ✓' if uses_ssh else 'not applicable'}\n"
+        f"[bold]💿 DB Backup:[/bold] {'included ✓' if db_backup_path else ('skipped (--no-db)' if no_db else 'not available')}\n\n"
+        f"[dim]Share the ZIP with the other developer.\n"
+        f"The recipient should run: [cyan]rkd unpack[/cyan][/dim]",
+        border_style="green",
+        box=box.ROUNDED
+    ))
+    console.print()

rocketdoo-2.3.0/rocketdoo/unpack_environment.py

@@ -0,0 +1,477 @@
+# rocketdoo/unpack_environment.py
+"""
+rkd unpack — Starts a development environment shared by another developer.
+
+Steps:
+  1. Detects rkd-shared.json to confirm this is a shared environment.
+  2. Validates that the environment's ports are available; suggests alternatives if not.
+  3. If the environment used private repos (SSH), lists the recipient's keys and
+     configures the Dockerfile with the chosen one.
+  4. Starts the environment with docker compose up -d.
+  5. If a database backup is present, automatically restores the DB and filestore.
+"""
+
+import json
+import re
+import subprocess
+import time
+from pathlib import Path
+
+import click
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+
+from rocketdoo.core.port_validation import is_port_in_use, find_available_port
+from rocketdoo.core.ssh_manager import list_private_keys, copy_key_to_build_context, inject_ssh_into_dockerfile
+from rocketdoo.project_info import project_exists, read_docker_compose
+
+console = Console()
+
+
+# ─────────────────────────────────────────────────────────────
+# Internal helpers
+# ─────────────────────────────────────────────────────────────
+
+def _load_shared_meta(project_dir: Path) -> dict | None:
+    """Loads the rkd-shared.json file if it exists."""
+    meta_path = project_dir / "rkd-shared.json"
+    if meta_path.exists():
+        try:
+            return json.loads(meta_path.read_text())
+        except Exception:
+            return None
+    return None
+
+
+def _find_backup_files(project_dir: Path) -> tuple[Path | None, Path | None]:
+    """
+    Searches for backup files inside the rkd_backups directory.
+    Returns (db_dump_path, filestore_tar_path) — None if not found.
+    """
+    backup_dir = project_dir / "rkd_backups"
+    if not backup_dir.exists():
+        return None, None
+
+    dumps = sorted(backup_dir.glob("db_*.dump"), reverse=True)
+    filestores = sorted(backup_dir.glob("filestore_*.tar.gz"), reverse=True)
+
+    return (dumps[0] if dumps else None), (filestores[0] if filestores else None)
+
+
+def _check_ports(meta: dict) -> tuple[int, int, bool]:
+    """
+    Verifies whether the environment's ports are available.
+    Returns (final_odoo_port, final_vsc_port, had_changes).
+    """
+    odoo_port = int(meta.get("odoo_port", 8069))
+    vsc_port = int(meta.get("vsc_port", 8888))
+    changed = False
+
+    console.print("[bold]🔍 Checking port availability...[/bold]")
+
+    if is_port_in_use(odoo_port):
+        suggested = find_available_port(odoo_port + 1)
+        console.print(f"  [yellow]⚠[/yellow]  Odoo port [cyan]{odoo_port}[/cyan] is already in use.")
+        console.print(f"  [dim]Suggested port: [green]{suggested}[/green][/dim]")
+        use_suggested = questionary.confirm(
+            f"Use port {suggested} for Odoo instead of {odoo_port}?", default=True
+        ).ask()
+        odoo_port = suggested if use_suggested else click.prompt("Enter Odoo port to use", type=int, default=suggested)
+        changed = True
+    else:
+        console.print(f"  [green]✓[/green] Odoo port [cyan]{odoo_port}[/cyan] is available.")
+
+    if is_port_in_use(vsc_port):
+        suggested_vsc = find_available_port(vsc_port + 1)
+        console.print(f"  [yellow]⚠[/yellow]  VSCode port [cyan]{vsc_port}[/cyan] is already in use.")
+        console.print(f"  [dim]Suggested port: [green]{suggested_vsc}[/green][/dim]")
+        use_suggested_vsc = questionary.confirm(
+            f"Use port {suggested_vsc} for VSCode instead of {vsc_port}?", default=True
+        ).ask()
+        vsc_port = suggested_vsc if use_suggested_vsc else click.prompt("Enter VSCode port to use", type=int, default=suggested_vsc)
+        changed = True
+    else:
+        console.print(f"  [green]✓[/green] VSCode port [cyan]{vsc_port}[/cyan] is available.")
+
+    return odoo_port, vsc_port, changed
+
+
+def _update_ports_in_compose(project_dir: Path, new_odoo_port: int, new_vsc_port: int):
+    """
+    Updates port mappings in docker-compose.yaml using plain text replacement
+    to preserve the original file format.
+    """
+    compose_path = project_dir / "docker-compose.yaml"
+    if not compose_path.exists():
+        compose_path = project_dir / "docker-compose.yml"
+    if not compose_path.exists():
+        return
+
+    content = compose_path.read_text()
+    content = re.sub(r'"\d+:8069"', f'"{new_odoo_port}:8069"', content)
+    content = re.sub(r'"\d+:8888"', f'"{new_vsc_port}:8888"', content)
+    compose_path.write_text(content)
+    console.print(f"  [green]✓[/green] docker-compose.yaml updated with new ports.")
+
+
+def _configure_ssh(project_dir: Path, meta: dict) -> bool:
+    """
+    Guides the recipient through configuring their own SSH key for the environment.
+    Returns True if configured successfully, False if skipped or failed.
+    """
+    console.print()
+    console.print("[bold]🔐 SSH configuration for private repositories:[/bold]")
+
+    original_key = meta.get("ssh_key_name")
+    if original_key:
+        console.print(f"  [dim]The original environment used key: [yellow]{original_key}[/yellow][/dim]")
+
+    console.print()
+    available_keys = list_private_keys()
+
+    if not available_keys:
+        console.print("  [yellow]⚠[/yellow]  No SSH keys found in ~/.ssh/")
+        console.print("  [dim]Generate one with: [cyan]ssh-keygen -t rsa -b 4096[/cyan][/dim]")
+        skip = questionary.confirm(
+            "Continue without SSH? (private repos will not work)", default=False
+        ).ask()
+        return not skip
+
+    console.print(f"  [dim]Found {len(available_keys)} SSH key(s) available.[/dim]")
+
+    selected_key = questionary.select(
+        "Select your SSH key for private repositories:",
+        choices=available_keys
+    ).ask()
+
+    if not selected_key:
+        return False
+
+    try:
+        dockerfile_path = project_dir / "Dockerfile"
+        console.print(f"  [dim]Copying key [cyan]{selected_key}[/cyan] to build context...[/dim]")
+        copy_key_to_build_context(selected_key, project_dir)
+
+        if dockerfile_path.exists():
+            inject_ssh_into_dockerfile(dockerfile_path, selected_key)
+            console.print(f"  [green]✓[/green] Dockerfile configured with key [cyan]{selected_key}[/cyan]")
+        else:
+            console.print("  [yellow]⚠[/yellow]  Dockerfile not found.")
+
+        return True
+    except Exception as e:
+        console.print(f"  [red]✗ Error configuring SSH:[/red] {e}")
+        return False
+
+
+def _get_db_container_name(project_dir: Path) -> str | None:
+    """Reads docker-compose and returns the database container name."""
+    compose_data = read_docker_compose()
+    if compose_data:
+        try:
+            return compose_data["services"]["db"]["container_name"]
+        except (KeyError, TypeError):
+            pass
+    return None
+
+
+def _get_odoo_container_name(project_dir: Path) -> str | None:
+    """Reads docker-compose and returns the web container name."""
+    compose_data = read_docker_compose()
+    if compose_data:
+        try:
+            return compose_data["services"]["web"]["container_name"]
+        except (KeyError, TypeError):
+            pass
+    return None
+
+
+def _wait_for_postgres(db_container: str, max_wait: int = 60) -> bool:
+    """Waits until PostgreSQL is ready to accept connections."""
+    console.print(f"  [dim]Waiting for PostgreSQL to be ready (max {max_wait}s)...[/dim]")
+    for i in range(max_wait):
+        result = subprocess.run(
+            ["docker", "exec", db_container, "pg_isready", "-U", "root"],
+            capture_output=True
+        )
+        if result.returncode == 0:
+            console.print(f"  [green]✓[/green] PostgreSQL is ready.")
+            return True
+        time.sleep(1)
+        if i % 10 == 9:
+            console.print(f"  [dim]  ...{i + 1}s[/dim]")
+    return False
+
+
+def _restore_database(db_container: str, dump_path: Path) -> str | None:
+    """
+    Restores the PostgreSQL dump into the container.
+    Returns the restored database name, or None if it failed.
+    """
+    stem = dump_path.stem
+    parts = stem.split("_")
+    db_name = "_".join(parts[1:-2]) if len(parts) >= 4 else (parts[1] if len(parts) > 1 else "odoo_restored")
+
+    console.print(f"  [dim]Restoring database [cyan]{db_name}[/cyan]...[/dim]")
+
+    try:
+        copy_result = subprocess.run(
+            ["docker", "cp", str(dump_path), f"{db_container}:/tmp/rkd_restore.dump"],
+            capture_output=True, text=True
+        )
+        if copy_result.returncode != 0:
+            console.print(f"  [red]✗ Error copying dump:[/red] {copy_result.stderr}")
+            return None
+
+        subprocess.run(
+            ["docker", "exec", db_container,
+             "psql", "-U", "root", "-d", "postgres", "-c",
+             f"DROP DATABASE IF EXISTS \"{db_name}\";"],
+            capture_output=True
+        )
+        create_result = subprocess.run(
+            ["docker", "exec", db_container,
+             "psql", "-U", "root", "-d", "postgres", "-c",
+             f"CREATE DATABASE \"{db_name}\" OWNER root;"],
+            capture_output=True, text=True
+        )
+        if create_result.returncode != 0:
+            console.print(f"  [red]✗ Error creating database:[/red] {create_result.stderr}")
+            return None
+
+        restore_result = subprocess.run(
+            ["docker", "exec", db_container,
+             "pg_restore", "-U", "root", "-d", db_name,
+             "--no-owner", "--role=root",
+             "/tmp/rkd_restore.dump"],
+            capture_output=True, text=True
+        )
+
+        # pg_restore may return warnings (returncode 1) but still succeed
+        if restore_result.returncode not in (0, 1):
+            console.print(f"  [red]✗ Restore error:[/red] {restore_result.stderr[:500]}")
+            return None
+
+        console.print(f"  [green]✓[/green] Database [cyan]{db_name}[/cyan] restored successfully.")
+        return db_name
+
+    except Exception as e:
+        console.print(f"  [red]✗ Exception during restore:[/red] {e}")
+        return None
+
+
+def _restore_filestore(odoo_container: str, filestore_tar: Path, db_name: str) -> bool:
+    """Restores the Odoo filestore into the web container."""
+    console.print(f"  [dim]Restoring filestore for [cyan]{db_name}[/cyan]...[/dim]")
+    try:
+        copy_result = subprocess.run(
+            ["docker", "cp", str(filestore_tar), f"{odoo_container}:/tmp/rkd_filestore.tar.gz"],
+            capture_output=True, text=True
+        )
+        if copy_result.returncode != 0:
+            console.print(f"  [yellow]⚠[/yellow]  Could not copy filestore: {copy_result.stderr}")
+            return False
+
+        filestore_base = "/var/lib/odoo/.local/share/Odoo/filestore"
+        subprocess.run(
+            ["docker", "exec", odoo_container, "mkdir", "-p", filestore_base],
+            capture_output=True
+        )
+
+        extract_result = subprocess.run(
+            ["docker", "exec", odoo_container,
+             "tar", "-xzf", "/tmp/rkd_filestore.tar.gz", "-C", filestore_base],
+            capture_output=True, text=True
+        )
+        if extract_result.returncode != 0:
+            console.print(f"  [yellow]⚠[/yellow]  Error extracting filestore: {extract_result.stderr}")
+            return False
+
+        console.print(f"  [green]✓[/green] Filestore restored inside the container.")
+        return True
+    except Exception as e:
+        console.print(f"  [yellow]⚠[/yellow]  Exception while restoring filestore: {e}")
+        return False
+
+
+def _launch_environment(build: bool = False):
+    """Runs docker compose up -d (with optional --build flag)."""
+    cmd = ["docker", "compose", "up", "-d"]
+    if build:
+        cmd.append("--build")
+    console.print()
+    console.print(f"[bold]🚀 Starting environment:[/bold] [dim]{' '.join(cmd)}[/dim]")
+    result = subprocess.run(cmd)
+    return result.returncode == 0
+
+
+def _launch_db_only():
+    """Starts only the db service to allow database restoration."""
+    console.print("[dim]  Starting database service only...[/dim]")
+    result = subprocess.run(
+        ["docker", "compose", "up", "-d", "db"],
+        capture_output=True, text=True
+    )
+    return result.returncode == 0
+
+
+# ─────────────────────────────────────────────────────────────
+# Main command
+# ─────────────────────────────────────────────────────────────
+
+@click.command(name="unpack")
+@click.option("--no-restore", is_flag=True, default=False,
+              help="Skip automatic database restoration.")
+@click.option("--build", is_flag=True, default=False,
+              help="Rebuild the Docker image before starting (recommended on first run).")
+def unpack_environment(no_restore, build):
+    """
+    📥 Start a development environment shared by another developer.
+
+    Run this inside the unzipped environment directory.
+    Automatically detects shared environments, validates ports,
+    configures your own SSH keys, and restores the database.
+
+    \b
+    Examples:
+      rkd unpack              → full setup (recommended)
+      rkd unpack --no-restore → skip DB restore
+      rkd unpack --build      → rebuild Docker image
+    """
+    console.print()
+    console.print(Panel(
+        "[bold cyan]📥 RKD Unpack — Start shared environment[/bold cyan]\n\n"
+        "[dim]This process will:[/dim]\n"
+        "  [green]✓[/green] Detect and validate the shared environment\n"
+        "  [green]✓[/green] Check port availability\n"
+        "  [green]✓[/green] Configure your SSH key if using private repos\n"
+        "  [green]✓[/green] Start the environment and restore the database",
+        border_style="cyan",
+        box=box.ROUNDED
+    ))
+    console.print()
+
+    project_dir = Path.cwd()
+
+    # ── 1. Detect project and metadata ──
+    if not project_exists():
+        console.print("[red]✗[/red] No Rocketdoo project found in this directory.")
+        console.print("[dim]Make sure you are inside the unzipped environment directory.[/dim]")
+        return
+
+    meta = _load_shared_meta(project_dir)
+
+    if meta and meta.get("rkd_shared"):
+        console.print("[green]✓[/green] Shared environment detected ([dim]rkd-shared.json[/dim])")
+        console.print()
+
+        info_table = Table(show_header=False, box=box.SIMPLE, padding=(0, 2))
+        info_table.add_column("", style="cyan bold", width=22)
+        info_table.add_column("", style="green")
+        info_table.add_row("📦 Project", meta.get("project_name", "unknown"))
+        info_table.add_row("🐳 Odoo", f"{meta.get('odoo_version', '?')} ({meta.get('odoo_edition', 'Community')})")
+        info_table.add_row("🗄️  PostgreSQL", str(meta.get("db_version", "?")))
+        info_table.add_row("🔐 Private repos", "Yes" if meta.get("uses_private_repos") else "No")
+        info_table.add_row("💾 DB Backup", "Included ✓" if meta.get("has_db_backup") else "Not included")
+        console.print(Panel(info_table, title="[bold]📋 Environment to start[/bold]",
+                            border_style="dim", box=box.ROUNDED))
+        console.print()
+    else:
+        console.print("[yellow]⚠[/yellow]  rkd-shared.json not found.")
+        console.print("[dim]This looks like a Rocketdoo project but was not packaged with [cyan]rkd pack[/cyan].[/dim]")
+        if not questionary.confirm("Continue anyway?", default=False).ask():
+            return
+        meta = {}
+
+    # ── 2. Check and adjust ports ──
+    console.print()
+    new_odoo_port, new_vsc_port, ports_changed = _check_ports(meta)
+
+    if ports_changed:
+        console.print()
+        console.print("[dim]  Updating docker-compose.yaml with new ports...[/dim]")
+        _update_ports_in_compose(project_dir, new_odoo_port, new_vsc_port)
+
+    # ── 3. Configure SSH if the environment used private repos ──
+    uses_private_repos = meta.get("uses_private_repos", False)
+
+    if uses_private_repos:
+        console.print()
+        console.print(Panel(
+            "This environment was set up with [bold]private repositories[/bold].\n"
+            "You need to configure [bold]your own SSH key[/bold] for it to work correctly.",
+            border_style="yellow",
+            box=box.ROUNDED
+        ))
+        wants_ssh = questionary.confirm(
+            "Do you use private repositories and want to configure your SSH key?", default=True
+        ).ask()
+
+        if wants_ssh:
+            ssh_ok = _configure_ssh(project_dir, meta)
+            if not ssh_ok:
+                console.print("[yellow]⚠[/yellow]  SSH not configured. Private repos may not work.")
+
+    elif not meta:
+        wants_ssh = questionary.confirm(
+            "Does this environment use private repositories? (requires SSH key)", default=False
+        ).ask()
+        if wants_ssh:
+            _configure_ssh(project_dir, {})
+
+    # ── 4. Locate backup files ──
+    db_dump, filestore_tar = _find_backup_files(project_dir)
+    has_backup = db_dump is not None
+
+    # ── 5. Start the environment ──
+    console.print()
+    if has_backup and not no_restore:
+        console.print("[bold]💾 Database backup found.[/bold]")
+        console.print("[dim]  Strategy: start DB → restore → start full environment[/dim]")
+        console.print()
+
+        db_up = _launch_db_only()
+        if not db_up:
+            console.print("[red]✗ Could not start the database service.[/red]")
+            return
+
+        db_container = _get_db_container_name(project_dir)
+        if db_container:
+            pg_ready = _wait_for_postgres(db_container)
+            if pg_ready:
+                console.print()
+                console.print("[bold]💾 Restoring database:[/bold]")
+                restored_db = _restore_database(db_container, db_dump)
+
+                if restored_db and filestore_tar:
+                    console.print()
+                    console.print("[bold]🗂️  Restoring filestore:[/bold]")
+                    console.print("[dim]  Starting web service to restore filestore...[/dim]")
+                    subprocess.run(["docker", "compose", "up", "-d", "web"], capture_output=True)
+                    time.sleep(5)
+
+                    odoo_container = _get_odoo_container_name(project_dir)
+                    if odoo_container:
+                        _restore_filestore(odoo_container, filestore_tar, restored_db)
+
+        _launch_environment(build=build)
+    else:
+        _launch_environment(build=build)
+
+    # ── 6. Final summary ──
+    console.print()
+    console.print(Panel(
+        f"[bold green]✅ Environment is ready[/bold green]\n\n"
+        f"[bold]🌐 Odoo:[/bold] [cyan underline]http://localhost:{new_odoo_port}[/cyan underline]\n"
+        f"[bold]🐛 Debug:[/bold] port [cyan]{new_vsc_port}[/cyan]\n\n"
+        f"[dim]Useful commands:\n"
+        f"  [cyan]rkd status[/cyan]   → check container status\n"
+        f"  [cyan]rkd logs[/cyan]     → view logs\n"
+        f"  [cyan]rkd info[/cyan]     → project information[/dim]",
+        border_style="green",
+        box=box.ROUNDED
+    ))
+    console.print()

{rocketdoo-2.2.3 → rocketdoo-2.3.0/rocketdoo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocketdoo
-Version: 2.2.3
+Version: 2.3.0
 Summary: Framework for creating Odoo development environments with Docker and custom templates.
 Author-email: Horacio Montaño <horaciomontano@hdmsoft.com.ar>
 License: GNU LESSER GENERAL PUBLIC LICENSE
@@ -62,7 +62,7 @@ License: GNU LESSER GENERAL PUBLIC LICENSE
         <div RKD as ROCKETDOO V2=""></div>
         
         Licencia: LGPL-3.0+
-        Versión: "2.2.3"
+        Versión: "2.3.0"
         Autor: Horacio Montaño, Elias Braceras
         Fecha: 16/10/2024
         Descripción: Framework to development Odoo
@@ -95,7 +95,7 @@ Odoo Development Framework
    - "Horacio Montaño" and "Elias Braceras"
 
 ## Version: 
-   - "2.2.3"
+   - "2.3.0"
 
 ----------------------------------------------------------------------------------------------------------------------------------------------------------
 

{rocketdoo-2.2.3 → rocketdoo-2.3.0}/rocketdoo.egg-info/SOURCES.txt

@@ -10,9 +10,11 @@ rocketdoo/deploy_cli.py
 rocketdoo/docker_cli.py
 rocketdoo/init_project.py
 rocketdoo/main.py
+rocketdoo/pack_environment.py
 rocketdoo/project_info.py
 rocketdoo/rocketdoo.py
 rocketdoo/scaffold.py
+rocketdoo/unpack_environment.py
 rocketdoo/welcome.py
 rocketdoo.egg-info/PKG-INFO
 rocketdoo.egg-info/SOURCES.txt