rocketdoo 3.2.0__tar.gz → 3.3.0__tar.gz

{rocketdoo-3.2.0 → rocketdoo-3.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 V3=""></div>
 
 Licencia: LGPL-3.0+
-Versión: "3.2.0"
+Versión: "3.3.0"
 Autor: Horacio Montaño
-Fecha: 29/08/2026
+Fecha: 14/09/2026
 Descripción: Framework to development Odoo

{rocketdoo-3.2.0/rocketdoo.egg-info → rocketdoo-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocketdoo
-Version: 3.2.0
+Version: 3.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,9 +62,9 @@ License: GNU LESSER GENERAL PUBLIC LICENSE
         <div RKD as ROCKETDOO V3=""></div>
         
         Licencia: LGPL-3.0+
-        Versión: "3.2.0"
+        Versión: "3.3.0"
         Autor: Horacio Montaño
-        Fecha: 29/08/2026
+        Fecha: 14/09/2026
         Descripción: Framework to development Odoo
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -97,7 +97,7 @@ Odoo Development Framework
    - "Horacio Montaño"
 
 ## Version: 
-   - "3.2.0"
+   - "3.3.0"
 
 ----------------------------------------------------------------------------------------------------------------------------------------------------------
 
@@ -472,6 +472,10 @@ rkd mail open    # Open http://localhost:8025 in your browser
 
 Mailpit is toggled by commenting/uncommenting its service block in `docker-compose.yaml` using special markers (`# rkd:mailpit`). When enabled, Odoo's SMTP configuration is automatically updated to route emails through Mailpit.
 
+`rkd mail on`/`off` also write a `Mailpit (rkd)` record straight into the project's `ir.mail_server` table (Odoo's technical settings, *Outgoing Mail Servers*), so emails are captured with no extra manual setup. `on` creates or reactivates that record with `sequence = 1`; `off` archives it (never deletes it), leaving any of your own mail servers untouched. With a single database this is automatic; with more than one, pass `--db NAME` to `on`, `off`, or `status` — with several databases and no `--db`, nothing is written or read and the command tells you to re-run with it. If the `db` container isn't reachable (project stopped, Docker not running), the rest of the command still runs and it reports the reason; re-running `rkd mail on` once the project is up fixes it.
+
+`rkd mail status` shows this record's state (active, archived, not created yet, or not checked, with the reason) plus any other active `ir.mail_server` in the database. **A `sequence = 1` on the Mailpit record does not guarantee it captures every email**: Odoo's server selection filters by `from_filter` before it sorts by sequence, so a server you (or a restored production dump) already have, with a `from_filter` matching the sender, can still win even with a higher sequence number. `mail status` warns loudly when another active server has `sequence <= 1` (it can win the sequence tie-break outright), and with a softer note whenever any other server is active at all, since `from_filter` can override sequence regardless.
+
 ---
 
 #### `rkd traefik` — Traefik Reverse Proxy
@@ -517,7 +521,7 @@ rkd instance status                  # Show configured environments
 - Stage: 2 workers, `log_level = info`, 1.5 GB memory limit
 - Production: 4 workers, `log_level = warn`, 2.5 GB memory limit, `proxy_mode = True`, `list_db = False`
 
-> **Note:** Docker deployment requires a running SSH agent with the relevant keys loaded (`ssh-add -l`). Password authentication requires `sshpass` installed on your local machine.
+> **Note:** Docker deployment requires a running SSH agent with the relevant keys loaded (`ssh-add -l`). Password authentication requires `sshpass` installed on your local machine; the password itself travels through the `SSHPASS` environment variable (`sshpass -e`), never as a command-line argument visible to other processes on the same host.
 
 ------------------------------------------------------------------------------------------------------------------------------------------------------
 

{rocketdoo-3.2.0 → rocketdoo-3.3.0}/README.md

@@ -15,7 +15,7 @@ Odoo Development Framework
    - "Horacio Montaño"
 
 ## Version: 
-   - "3.2.0"
+   - "3.3.0"
 
 ----------------------------------------------------------------------------------------------------------------------------------------------------------
 
@@ -390,6 +390,10 @@ rkd mail open    # Open http://localhost:8025 in your browser
 
 Mailpit is toggled by commenting/uncommenting its service block in `docker-compose.yaml` using special markers (`# rkd:mailpit`). When enabled, Odoo's SMTP configuration is automatically updated to route emails through Mailpit.
 
+`rkd mail on`/`off` also write a `Mailpit (rkd)` record straight into the project's `ir.mail_server` table (Odoo's technical settings, *Outgoing Mail Servers*), so emails are captured with no extra manual setup. `on` creates or reactivates that record with `sequence = 1`; `off` archives it (never deletes it), leaving any of your own mail servers untouched. With a single database this is automatic; with more than one, pass `--db NAME` to `on`, `off`, or `status` — with several databases and no `--db`, nothing is written or read and the command tells you to re-run with it. If the `db` container isn't reachable (project stopped, Docker not running), the rest of the command still runs and it reports the reason; re-running `rkd mail on` once the project is up fixes it.
+
+`rkd mail status` shows this record's state (active, archived, not created yet, or not checked, with the reason) plus any other active `ir.mail_server` in the database. **A `sequence = 1` on the Mailpit record does not guarantee it captures every email**: Odoo's server selection filters by `from_filter` before it sorts by sequence, so a server you (or a restored production dump) already have, with a `from_filter` matching the sender, can still win even with a higher sequence number. `mail status` warns loudly when another active server has `sequence <= 1` (it can win the sequence tie-break outright), and with a softer note whenever any other server is active at all, since `from_filter` can override sequence regardless.
+
 ---
 
 #### `rkd traefik` — Traefik Reverse Proxy
@@ -435,7 +439,7 @@ rkd instance status                  # Show configured environments
 - Stage: 2 workers, `log_level = info`, 1.5 GB memory limit
 - Production: 4 workers, `log_level = warn`, 2.5 GB memory limit, `proxy_mode = True`, `list_db = False`
 
-> **Note:** Docker deployment requires a running SSH agent with the relevant keys loaded (`ssh-add -l`). Password authentication requires `sshpass` installed on your local machine.
+> **Note:** Docker deployment requires a running SSH agent with the relevant keys loaded (`ssh-add -l`). Password authentication requires `sshpass` installed on your local machine; the password itself travels through the `SSHPASS` environment variable (`sshpass -e`), never as a command-line argument visible to other processes on the same host.
 
 ------------------------------------------------------------------------------------------------------------------------------------------------------
 

{rocketdoo-3.2.0 → rocketdoo-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rocketdoo"
-version = "3.2.0"
+version = "3.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-3.2.0 → rocketdoo-3.3.0}/rocketdoo/core/deploy/vps.py

@@ -13,7 +13,7 @@ from typing import Dict, List
 from rich.console import Console
 from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn
 
-from rocketdoo.core.ssh_manager import check_sshpass, env_ref_name, resolve_env_ref
+from rocketdoo.core.ssh_manager import check_sshpass, env_ref_name, resolve_env_ref, sshpass_wrap
 
 from .base import BaseDeployer, DeploymentResult
 from .module_packager import ModulePackager
@@ -110,6 +110,11 @@ class VPSDeployer(BaseDeployer):
 
             console.print(f"[green]✔ Password stored securely at {secret_file}[/green]")
 
+    @property
+    def _sshpass_password(self) -> str | None:
+        """The password to feed sshpass, or None when authenticating with a key."""
+        return self.password if self.auth_method == "password" else None
+
     def validate_config(self) -> List[str]:
         """
         Validate VPS configuration
@@ -388,11 +393,23 @@ class VPSDeployer(BaseDeployer):
         Returns:
             CompletedProcess with result
         """
-        # Handle sudo with password authentication
+        # Handle sudo with password authentication. The password never touches
+        # the command string: it travels through the stdin of subprocess.run,
+        # which ssh forwards over the encrypted channel to the remote sudo -S.
+        # This keeps the password out of `ps aux` on both ends and, unlike the
+        # old `echo '{password}' | sudo -S` interpolation, means the password's
+        # content can never alter the structure of the remote command.
+        # The password goes to sudo's stdin, so a remote command that reads
+        # stdin itself cannot be run with use_sudo=True: it would consume the
+        # password line. Today none of the callers do (the only two are
+        # `mkdir` and `systemctl restart`).
+        sudo_input = None
         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}"
+                command = f"sudo -S -p '' {command}"
+                # Only the first line reaches sudo; a multi-line password would
+                # leave the rest in the remote command's stdin.
+                sudo_input = self.password.splitlines()[0] + "\n" if self.password else None
             else:
                 # Try passwordless sudo or rely on SSH key having sudo access
                 command = f"sudo {command}"
@@ -406,9 +423,6 @@ class VPSDeployer(BaseDeployer):
         if self.auth_method == "ssh_key" and self.ssh_key:
             key_path = os.path.expanduser(self.ssh_key)
             ssh_cmd.extend(["-i", key_path])
-        elif self.auth_method == "password" and self.password:
-            # Use sshpass for password authentication
-            ssh_cmd = ["sshpass", "-p", self.password] + ssh_cmd
 
         # Add user@host
         ssh_cmd.append(f"{self.user}@{self.host}")
@@ -416,9 +430,11 @@ class VPSDeployer(BaseDeployer):
         # Add command
         ssh_cmd.append(command)
 
+        ssh_cmd, env = sshpass_wrap(self._sshpass_password, ssh_cmd)
+
         # Execute
         try:
-            result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=timeout)
+            result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=timeout, env=env, input=sudo_input)
             return result
         except FileNotFoundError as e:
             if "sshpass" in str(e):
@@ -447,9 +463,6 @@ class VPSDeployer(BaseDeployer):
             if self.auth_method == "ssh_key" and self.ssh_key:
                 key_path = os.path.expanduser(self.ssh_key)
                 ssh_opts += f" -i {key_path}"
-            elif self.auth_method == "password" and self.password:
-                # Use sshpass for rsync with password
-                rsync_cmd = ["sshpass", "-p", self.password] + rsync_cmd
 
             rsync_cmd.extend(["-e", f"ssh {ssh_opts}"])
 
@@ -457,8 +470,10 @@ class VPSDeployer(BaseDeployer):
             rsync_cmd.append(f"{local_path}/")
             rsync_cmd.append(f"{self.user}@{self.host}:{remote_path}/")
 
+            rsync_cmd, env = sshpass_wrap(self._sshpass_password, rsync_cmd)
+
             # Execute rsync
-            result = subprocess.run(rsync_cmd, capture_output=True, text=True, timeout=600)
+            result = subprocess.run(rsync_cmd, capture_output=True, text=True, timeout=600, env=env)
 
             if result.returncode != 0:
                 self.log(f"rsync failed: {result.stderr}", "error")
@@ -500,16 +515,15 @@ class VPSDeployer(BaseDeployer):
             if self.auth_method == "ssh_key" and self.ssh_key:
                 key_path = os.path.expanduser(self.ssh_key)
                 scp_cmd.extend(["-i", key_path])
-            elif self.auth_method == "password" and self.password:
-                # Use sshpass for password authentication
-                scp_cmd = ["sshpass", "-p", self.password] + scp_cmd
 
             # Add source and destination
             scp_cmd.append(str(local_path))
             scp_cmd.append(f"{self.user}@{self.host}:{remote_path}")
 
+            scp_cmd, env = sshpass_wrap(self._sshpass_password, scp_cmd)
+
             # Execute
-            result = subprocess.run(scp_cmd, capture_output=True, text=True, timeout=300)
+            result = subprocess.run(scp_cmd, capture_output=True, text=True, timeout=300, env=env)
 
             return result.returncode == 0
 

{rocketdoo-3.2.0 → rocketdoo-3.3.0}/rocketdoo/core/instance/deployer_docker.py

@@ -140,7 +140,7 @@ class DockerInstanceDeployer:
     def _read_remote_pg_pass(self) -> str | None:
         """Return odoo_pg_pass from a previous deploy, or None if unavailable."""
         remote_file = f"{self.remote_path}/{self.env}/odoo_pg_pass"
-        cmd = build_ssh_cmd(
+        cmd, env = build_ssh_cmd(
             self.auth,
             self.port,
             self.user,
@@ -148,7 +148,7 @@ class DockerInstanceDeployer:
             f"cat {remote_file} 2>/dev/null",
         )
         try:
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60, env=env)
         except (subprocess.SubprocessError, OSError):
             return None
         return result.stdout.strip() or None
@@ -228,12 +228,12 @@ class DockerInstanceDeployer:
     # ─── SSH / transfer helpers ───────────────────────────────────────────────
 
     def _ssh(self, command: str, agent_forward: bool = False, timeout: int = 600) -> bool:
-        cmd = build_ssh_cmd(self.auth, self.port, self.user, self.host, command, agent_forward=agent_forward)
-        return subprocess.run(cmd, timeout=timeout).returncode == 0
+        cmd, env = build_ssh_cmd(self.auth, self.port, self.user, self.host, command, agent_forward=agent_forward)
+        return subprocess.run(cmd, timeout=timeout, env=env).returncode == 0
 
     def _rsync(self, local: str, remote: str, extra_opts: list[str] | None = None) -> bool:
-        cmd = build_rsync_cmd(self.auth, self.port, self.user, self.host, local, remote, extra_opts)
-        return subprocess.run(cmd).returncode == 0
+        cmd, env = build_rsync_cmd(self.auth, self.port, self.user, self.host, local, remote, extra_opts)
+        return subprocess.run(cmd, env=env).returncode == 0
 
     # ─── deployment steps ────────────────────────────────────────────────────
 

{rocketdoo-3.2.0 → rocketdoo-3.3.0}/rocketdoo/core/instance/deployer_native.py

@@ -160,9 +160,11 @@ class NativeInstanceDeployer:
             "list_db = False\n"
         )
 
-        # Write conf via heredoc on remote. The heredoc delimiter is quoted
-        # (<< \'ENDCONF\'), so the shell performs no expansion on the body.
-        return self._ssh(f"sudo bash -c 'cat > {self.odoo_conf_path} << \\'ENDCONF\\'\n{conf}\nENDCONF'")
+        # The conf body (including admin_passwd) travels through stdin rather
+        # than being embedded in the command string: it never touches argv,
+        # so it cannot appear in `ps aux` and cannot be affected by shell
+        # quoting rules regardless of what a value contains.
+        return self._ssh(f"sudo tee {self.odoo_conf_path} > /dev/null", input=conf)
 
     def _sync_addons(self) -> bool:
         addons_dir = self.project_path / "addons"
@@ -171,8 +173,8 @@ class NativeInstanceDeployer:
             return True
 
         self._ssh(f"sudo mkdir -p {self.remote_addons} && sudo chown {self.user} {self.remote_addons}")
-        cmd = build_rsync_cmd(self.auth, self.port, self.user, self.host, f"{addons_dir}/", f"{self.remote_addons}/")
-        result = subprocess.run(cmd)
+        cmd, env = build_rsync_cmd(self.auth, self.port, self.user, self.host, f"{addons_dir}/", f"{self.remote_addons}/")
+        result = subprocess.run(cmd, env=env)
         return result.returncode == 0
 
     def _enable_service(self) -> bool:
@@ -180,9 +182,9 @@ class NativeInstanceDeployer:
 
     # ─── helpers ─────────────────────────────────────────────────────────────
 
-    def _ssh(self, command: str, timeout: int = 300) -> bool:
-        cmd = build_ssh_cmd(self.auth, self.port, self.user, self.host, command)
-        return subprocess.run(cmd, timeout=timeout).returncode == 0
+    def _ssh(self, command: str, timeout: int = 300, input: str | None = None) -> bool:
+        cmd, env = build_ssh_cmd(self.auth, self.port, self.user, self.host, command)
+        return subprocess.run(cmd, timeout=timeout, env=env, input=input, text=True).returncode == 0
 
     def _show_plan(self):
         console.print("\n[bold]DRY-RUN — Steps that would be executed:[/bold]")

{rocketdoo-3.2.0 → rocketdoo-3.3.0}/rocketdoo/core/instance/ssh_utils.py

@@ -4,7 +4,7 @@ Shared by DockerInstanceDeployer and NativeInstanceDeployer.
 
 Mirrors the auth pattern from core/deploy/vps.py:
   - ssh_key  → -i key_path
-  - password → sshpass -p <pass>  (requires sshpass installed)
+  - password → sshpass -e     (password read from the SSHPASS env var, requires sshpass installed)
 """
 
 import os
@@ -14,7 +14,7 @@ from pathlib import Path
 
 from rich.console import Console
 
-from rocketdoo.core.ssh_manager import check_sshpass, env_ref_name, resolve_env_ref
+from rocketdoo.core.ssh_manager import check_sshpass, env_ref_name, resolve_env_ref, sshpass_wrap
 
 console = Console()
 
@@ -75,24 +75,8 @@ def resolve_auth(vps_cfg: dict, env: str, project_path: Path) -> dict:
     return {"method": "password", "key_path": None, "password": password}
 
 
-def ssh_prefix(auth: dict) -> list[str]:
-    """
-    Return the command prefix for SSH/rsync based on auth method.
-
-    ssh_key  → []                          (key added via ssh_opts)
-    password → ['sshpass', '-p', '<pass>']
-    """
-    if auth["method"] == "password":
-        return ["sshpass", "-p", auth["password"]]
-    return []
-
-
 def ssh_opts(auth: dict, port: int, agent_forward: bool = False) -> list[str]:
-    """
-    Return SSH -o/-i/-A options (without the leading 'ssh').
-
-    Combine with ssh_prefix() for password auth.
-    """
+    """Return SSH -o/-i/-A options (without the leading 'ssh')."""
     opts = [
         "-p",
         str(port),
@@ -108,24 +92,28 @@ def ssh_opts(auth: dict, port: int, agent_forward: bool = False) -> list[str]:
     return opts
 
 
-def build_ssh_cmd(auth: dict, port: int, user: str, host: str, command: str, agent_forward: bool = False) -> list[str]:
-    """Full SSH command list ready for subprocess.run()."""
-    return [
-        *ssh_prefix(auth),
+def build_ssh_cmd(
+    auth: dict, port: int, user: str, host: str, command: str, agent_forward: bool = False
+) -> tuple[list[str], dict | None]:
+    """Full (cmd, env) pair ready for subprocess.run()."""
+    argv = [
         "ssh",
         *ssh_opts(auth, port, agent_forward),
         f"{user}@{host}",
         command,
     ]
+    # Keyed on the method, as ssh_prefix() was: a dict built by hand without
+    # a "password" key should not silently fall through to key auth.
+    password = auth["password"] if auth["method"] == "password" else None
+    return sshpass_wrap(password, argv)
 
 
 def build_rsync_cmd(
     auth: dict, port: int, user: str, host: str, local: str, remote: str, extra_opts: list[str] | None = None
-) -> list[str]:
-    """rsync command list ready for subprocess.run()."""
+) -> tuple[list[str], dict | None]:
+    """rsync (cmd, env) pair ready for subprocess.run()."""
     ssh_e = "ssh " + " ".join(ssh_opts(auth, port))
-    return [
-        *ssh_prefix(auth),
+    argv = [
         "rsync",
         "-avz",
         "--delete",
@@ -135,3 +123,7 @@ def build_rsync_cmd(
         local,
         f"{user}@{host}:{remote}",
     ]
+    # Keyed on the method, as ssh_prefix() was: a dict built by hand without
+    # a "password" key should not silently fall through to key auth.
+    password = auth["password"] if auth["method"] == "password" else None
+    return sshpass_wrap(password, argv)

rocketdoo-3.3.0/rocketdoo/core/odoo_db.py

@@ -0,0 +1,191 @@
+"""Access to the project's PostgreSQL container: reads and Mailpit writes.
+
+The `pg_database` query and the container lookup used to live only in
+`pack_environment`; the GUI module-update feature needs the same data, so
+this consolidates them into a single place (like `core/compose.py` did for
+`docker compose` in #137) instead of growing a third copy. `rkd mail on/off`
+also writes the Rocketdoo `ir.mail_server` row here (#176), so this module is
+no longer read-only.
+"""
+
+import subprocess
+
+from rocketdoo.project_info import read_docker_compose
+
+PSQL_USER = "root"  # POSTGRES_USER set by the docker-compose template
+
+MAILPIT_SERVER_NAME = "Mailpit (rkd)"
+MAILPIT_SMTP_HOST = "mailpit"
+MAILPIT_SMTP_PORT = 1025
+MAILPIT_SEQUENCE = 1  # Odoo's default is 10: Mailpit must win the tie
+
+
+def db_container(compose_data: dict | None = None) -> str | None:
+    """Return the `db` service's container name, or None if it can't be read."""
+    if compose_data is None:
+        compose_data = read_docker_compose()
+    try:
+        return compose_data["services"]["db"]["container_name"]
+    except (KeyError, TypeError):
+        return None
+
+
+def _psql(db: str, sql: str, *flags: str, compose_data: dict | None = None) -> tuple[str, str]:
+    """Run `sql` against `db` via `docker exec ... psql`. Returns (stdout, error).
+
+    A non-empty error means the query did not run: stdout is not meaningful.
+    Shared by every query/write in this module so the argv and the error
+    translation (missing docker, unreachable container, psql failure) live in
+    one place.
+    """
+    container = db_container(compose_data)
+    if not container:
+        return "", "no database container configured"
+
+    try:
+        result = subprocess.run(
+            ["docker", "exec", container, "psql", "-U", PSQL_USER, "-d", db, *flags, "-c", sql],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except FileNotFoundError:
+        return "", "docker not found"
+    except (OSError, subprocess.SubprocessError) as exc:
+        return "", str(exc)
+
+    if result.returncode != 0:
+        return "", result.stderr.strip()
+
+    return result.stdout, ""
+
+
+def databases_result(compose_data: dict | None = None) -> tuple[list[str], str]:
+    """List of user databases plus the reason it came back empty, if any.
+
+    Excludes `postgres` and the templates, matching what `rkd pack` already
+    queried. Any failure to reach the container yields an empty list.
+    """
+    stdout, error = _psql(
+        "postgres",
+        "SELECT datname FROM pg_database WHERE datistemplate = false AND datname != 'postgres';",
+        "-t",
+        compose_data=compose_data,
+    )
+    if error:
+        return [], error
+
+    return [line.strip() for line in stdout.splitlines() if line.strip()], ""
+
+
+def list_databases(compose_data: dict | None = None) -> list[str]:
+    """List of user databases. Use `databases_result` when the reason matters."""
+    return databases_result(compose_data)[0]
+
+
+def module_states(db: str) -> tuple[dict[str, str], str]:
+    """Map `{module_name: state}` read from `ir_module_module` in `db`.
+
+    `db` is not validated here: that is the trust boundary's job (the GUI
+    layer), and keeping it in one place avoids the validation being
+    duplicated with different criteria. If `db` isn't an Odoo database,
+    psql fails and ({}, stderr) is returned.
+    """
+    stdout, error = _psql(db, "SELECT name, state FROM ir_module_module;", "-t", "-A", "-F", "\t")
+    if error:
+        return {}, error
+
+    states = {}
+    for line in stdout.splitlines():
+        name, _, state = line.strip().partition("\t")
+        if name and state:
+            states[name] = state
+    return states, ""
+
+
+def mail_servers(db: str) -> tuple[list[dict], str]:
+    """Every ir.mail_server row in `db`, ordered the way Odoo orders them.
+
+    All rows are returned, active or not, so `rkd mail status` can tell
+    "archived" from "never created" with a single query.
+    """
+    stdout, error = _psql(
+        db,
+        "SELECT id, name, sequence, smtp_host, active FROM ir_mail_server ORDER BY sequence, id;",
+        "-t",
+        "-A",
+        "-F",
+        "\t",
+    )
+    if error:
+        return [], error
+
+    servers = []
+    for line in stdout.splitlines():
+        fields = line.split("\t")
+        if len(fields) != 5:
+            continue
+        raw_id, name, raw_sequence, smtp_host, raw_active = fields
+        try:
+            server_id = int(raw_id)
+            sequence = int(raw_sequence)
+        except ValueError:
+            continue
+        servers.append(
+            {
+                "id": server_id,
+                "name": name,
+                "sequence": sequence,
+                "smtp_host": smtp_host,
+                "active": raw_active == "t",
+            }
+        )
+    return servers, ""
+
+
+def enable_mailpit_server(db: str) -> str:
+    """Create or reactivate the Rocketdoo mail server. Returns '' on success.
+
+    Matched by name + smtp_host, not by id: there is no UNIQUE constraint on
+    name to key an UPSERT off. Idempotent by construction, so callers can run
+    it unconditionally instead of tracking local state.
+    """
+    sql = (
+        "WITH updated AS ("
+        "UPDATE ir_mail_server "
+        f"SET active = true, smtp_port = {MAILPIT_SMTP_PORT}, sequence = {MAILPIT_SEQUENCE}, write_date = now() "
+        f"WHERE name = '{MAILPIT_SERVER_NAME}' AND smtp_host = '{MAILPIT_SMTP_HOST}' "
+        "RETURNING id"
+        ") "
+        "INSERT INTO ir_mail_server "
+        "(name, smtp_host, smtp_port, smtp_encryption, smtp_authentication, sequence, active, create_date, write_date) "
+        f"SELECT '{MAILPIT_SERVER_NAME}', '{MAILPIT_SMTP_HOST}', {MAILPIT_SMTP_PORT}, 'none', 'login', "
+        f"{MAILPIT_SEQUENCE}, true, now(), now() "
+        "WHERE NOT EXISTS (SELECT 1 FROM updated);"
+    )
+    _, error = _psql(db, sql)
+    return error
+
+
+def disable_mailpit_server(db: str) -> tuple[int, str]:
+    """Archive the Rocketdoo mail server. Returns (rows archived, error).
+
+    Only rows matching both name and smtp_host are touched, and only
+    archived: never DELETE, so a record a user renamed or repurposed is
+    never at risk even if it collides on one of the two conditions.
+    """
+    sql = (
+        "UPDATE ir_mail_server SET active = false, write_date = now() "
+        f"WHERE name = '{MAILPIT_SERVER_NAME}' AND smtp_host = '{MAILPIT_SMTP_HOST}' "
+        "RETURNING id;"
+    )
+    # -q suppresses psql's status line: without it, `RETURNING id` with zero
+    # rows still prints "UPDATE 0", which counts as a row and makes the command
+    # report an archive that never happened.
+    stdout, error = _psql(db, sql, "-q", "-t", "-A")
+    if error:
+        return 0, error
+
+    # Count returned ids, not non-empty lines: psql's status line ("UPDATE 0")
+    # is not a row, and counting it reports an archive that never happened.
+    return len([line for line in stdout.splitlines() if line.strip().isdigit()]), ""

{rocketdoo-3.2.0 → rocketdoo-3.3.0}/rocketdoo/core/ssh_manager.py

@@ -58,3 +58,16 @@ def resolve_env_ref(value: str) -> str:
     if name is None:
         return value
     return os.environ.get(name, "")
+
+
+def sshpass_wrap(password: str | None, argv: list[str]) -> tuple[list[str], dict | None]:
+    """Return (argv, env) for a command that may need password authentication.
+
+    The password travels in the SSHPASS environment variable of the child
+    process, never as an argv element readable through `ps`. Without a
+    password the command is returned untouched and env is None, which makes
+    subprocess inherit the parent environment exactly as before.
+    """
+    if not password:
+        return argv, None
+    return ["sshpass", "-e", *argv], {**os.environ, "SSHPASS": password}

{rocketdoo-3.2.0 → rocketdoo-3.3.0}/rocketdoo/gui/api/__init__.py

@@ -6,6 +6,7 @@ from .gitman import router as gitman_router
 from .instances import router as instances_router
 from .mail import router as mail_router
 from .modules import router as modules_router
+from .odoo import router as odoo_router
 from .pack_ops import router as pack_router
 from .project import router as project_router
 from .setup import router as setup_router
@@ -17,6 +18,7 @@ router.include_router(workspace_router, prefix="/workspace", tags=["workspace"])
 router.include_router(project_router, prefix="/project", tags=["project"])
 router.include_router(docker_router, prefix="/docker", tags=["docker"])
 router.include_router(modules_router, prefix="/modules", tags=["modules"])
+router.include_router(odoo_router, prefix="/odoo", tags=["odoo"])
 router.include_router(gitman_router, prefix="/gitman", tags=["gitman"])
 router.include_router(mail_router, prefix="/mail", tags=["mail"])
 router.include_router(traefik_router, prefix="/traefik", tags=["traefik"])