[REF] core: support streaming process output and AI CLI integration (#134)

* [REF] core: support AI CLI sandboxed execution

* fix(rest): add ConnectionResetError to retryable exceptions

The REST connector now catches ConnectionResetError in addition to RequestsConnectionError during requests. This ensures that the built-in retry logic is triggered when a connection is reset by the peer, improving resilience against transient network issues.

* fix(test): improve debugger detection regex

* [IMP] rest: improve cookie handling and fix caching order

Author: sea-odoo

odev/__main__.py

@@ -35,7 +35,7 @@ def main():
         odev = init_framework()
         odev.start(start_time)
         logger.debug(f"Framework started in {monotonic() - start_time:.3f} seconds")
-        odev.dispatch()
+        sys.exit(0 if odev.dispatch() else 1)
 
     except OdevError as error:
         logger.error(error)

odev/_version.py

@@ -22,4 +22,4 @@
 # or merged change.
 # ------------------------------------------------------------------------------
 
-__version__ = "4.26.0"
+__version__ = "4.27.0"

odev/commands/database/cloc.py

@@ -40,7 +40,7 @@ def run(self):
 
         process = self.odoobin.run(args=self.args.odoo_args, subcommand=self._name, stream=False)
 
-        if process is None:
+        if process is None or process.returncode:
             raise self.error("Failed to fetch cloc result.")
 
         headers = [

odev/commands/database/create.py

@@ -39,6 +39,7 @@ class CreateCommand(OdoobinTemplateCommand):
     )
     version_argument = args.String(
         name="version",
+        aliases=["-V", "--version"],
         description="""The Odoo version to use for the new database.
         If not specified and a template is provided, the version of
         the template database will be used. Otherwise, the version will default to "master".

odev/commands/database/delete.py

@@ -76,7 +76,7 @@ def run(self):
         databases_list: str = string.join_and([f"{db!r}" for db in databases])
         logger.warning(f"You are about to delete the following databases: {databases_list}")
 
-        if not self.console.confirm("Are you sure?", default=False):
+        if not self.console.confirm("Are you sure?", default=self.args.bypass_prompt):
             raise self.error("Command aborted")
 
         tracker = progress.Progress()

odev/commands/database/run.py

@@ -76,4 +76,7 @@ def run(self):
         if self.odoobin.is_running:
             raise self.error(f"Database {self._database.name!r} is already running")
 
-        self.odoobin.run(args=self.args.odoo_args, progress=self.odoobin_progress)
+        process = self.odoobin.run(args=self.args.odoo_args, progress=self.odoobin_progress)
+
+        if process and process.returncode:
+            raise self.error("Odoo process failed")

odev/commands/database/test.py

@@ -38,6 +38,11 @@ class TestCommand(OdoobinCommand):
         description="Comma-separated list of modules to install for testing. If not set, install the base module.",
     )
 
+    @property
+    def _database_exists_required(self) -> bool:
+        """Return True if a database has to exist for the command to work."""
+        return not bool(self.args.version)
+
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.test_files: list[str] = []
@@ -84,8 +89,8 @@ def create_test_database(self):
         """Return the arguments to pass to the create command."""
         args = ["--bare"]
 
-        if self._database.version is not None:
-            args.extend(["--version", str(self._database.version)])
+        if self.version is not None:
+            args.extend(["--version", str(self.version)])
 
         args.append(self.test_database.name)
         self.odev.run_command("create", *args)
@@ -109,8 +114,14 @@ def run_test_database(self):
             self.create_test_database()
 
         odoobin = self.test_database.process or OdoobinProcess(self.test_database)
-        odoobin.with_version(self._database.version)
-        odoobin.with_edition(self._database.edition)
+        odoobin.with_version(self.version)
+
+        edition = (
+            "enterprise"
+            if self.args.enterprise or (self._database.exists and self._database.edition == "enterprise")
+            else "community"
+        )
+        odoobin.with_edition(edition)
         odoobin.with_venv(self.venv)
         odoobin.with_worktree(self.worktree)
 
@@ -126,16 +137,20 @@ def run_test_database(self):
 
     def odoobin_progress(self, line: str):
         """Handle odoo-bin output and fetch information real-time."""
-        if re.match(r"^(i?pu?db)?>+", line):
+        if re.match(r"^(?:ipdb|pudb|pdb)>+|^\(Pdb\)|(?:^>\s+.*\.(?:py|js)\(\d+\))", line):
             raise self.error("Debugger detected in odoo-bin output, remove breakpoints and try again")
 
         problematic_test_levels = ("warning", "error", "critical")
         match = self._parse_progress_log_line(line)
 
-        if match is None:
-            if self.last_level in problematic_test_levels:
+        if match is None or not self.args.pretty:
+            if match is None and self.last_level in problematic_test_levels:
                 self.test_buffer.append(line)
 
+            if not self.args.pretty:
+                self.print(line, highlight=False, soft_wrap=False)
+                return
+
             color = f"logging.level.{self.last_level}" if self.last_level in problematic_test_levels else "color.black"
             self.print(string.stylize(line, color), highlight=False, soft_wrap=False)
             return

odev/commands/git/worktree.py

@@ -90,7 +90,8 @@ def create_worktree(self):
         self.__check_name()
 
         if self.args.name in self.grouped_worktrees:
-            raise self.error(f"Worktree with name '{self.args.name}' already exists")
+            logger.info(f"Worktree with name '{self.args.name}' already exists")
+            return
 
         with progress.spinner(f"Creating worktree {self.args.name}"):
             for repository in self.repositories:

odev/common/bash.py

@@ -36,7 +36,9 @@
 # --- Helpers ------------------------------------------------------------------
 
 
-def __run_command(command: str, capture: bool = True, sudo_password: str | None = None) -> CompletedProcess[bytes]:
+def __run_command(
+    command: str, capture: bool = True, sudo_password: str | None = None, env: dict[str, str] | None = None
+) -> CompletedProcess[bytes]:
     """Execute a command as a subprocess.
     If `sudo_password` is provided and not `None`, the command will be executed with
     elevated privileges.
@@ -45,6 +47,7 @@ def __run_command(command: str, capture: bool = True, sudo_password: str | None
     :param bool capture: Whether to capture the output of the command.
     :param str sudo_password: The password to use when executing the command with
         elevated privileges.
+    :param dict env: The environment variables to use when executing the command.
     :return: The result of the command execution.
     :rtype: CompletedProcess
     """
@@ -58,6 +61,7 @@ def __run_command(command: str, capture: bool = True, sudo_password: str | None
         check=True,
         capture_output=capture,
         input=sudo_password.encode() if sudo_password is not None else None,
+        env=env,
     )
 
 
@@ -80,7 +84,9 @@ def __raise_or_log(exception: CalledProcessError, do_raise: bool) -> None:
 # --- Public API ---------------------------------------------------------------
 
 
-def execute(command: str, sudo: bool = False, raise_on_error: bool = True) -> CompletedProcess[bytes] | None:
+def execute(
+    command: str, sudo: bool = False, raise_on_error: bool = True, env: dict[str, str] | None = None
+) -> CompletedProcess[bytes] | None:
     """Execute a command in the operating system and wait for it to complete.
     Output of the command will be captured and returned after the execution completes.
 
@@ -97,7 +103,7 @@ def execute(command: str, sudo: bool = False, raise_on_error: bool = True) -> Co
     """
     try:
         logger.debug(f"Running process: {shlex.quote(command)}")
-        process_result = __run_command(command)
+        process_result = __run_command(command, env=env)
     except CalledProcessError as exception:
         # If already running as root, sudo will not work
         if not sudo or not os.geteuid():
@@ -112,7 +118,7 @@ def execute(command: str, sudo: bool = False, raise_on_error: bool = True) -> Co
             return None
 
         try:
-            process_result = __run_command(command, sudo_password=sudo_password)
+            process_result = __run_command(command, sudo_password=sudo_password, env=env)
         except CalledProcessError as exception:
             sudo_password = None
             __raise_or_log(exception, raise_on_error)
@@ -121,15 +127,16 @@ def execute(command: str, sudo: bool = False, raise_on_error: bool = True) -> Co
     return process_result
 
 
-def run(command: str) -> CompletedProcess:
+def run(command: str, env: dict[str, str] | None = None) -> CompletedProcess:
     """Execute a command in the operating system and wait for it to complete.
     Output of the command will not be captured and will be printed to the console
     in real-time.
 
     :param str command: The command to execute.
+    :param dict env: The environment variables to use when executing the command.
     """
     logger.debug(f"Running process: {shlex.quote(command)}")
-    return __run_command(command, capture=False)
+    return __run_command(command, capture=False, env=env)
 
 
 def detached(command: str) -> Popen[bytes]:
@@ -141,15 +148,16 @@ def detached(command: str) -> Popen[bytes]:
     return Popen(command, shell=True, start_new_session=True, stdout=DEVNULL, stderr=DEVNULL)  # noqa: S602 - intentional use of shell=True
 
 
-def stream(command: str) -> Generator[str, None, None]:  # noqa: PLR0912
+def stream(command: str, env: dict[str, str] | None = None) -> Generator[str, None, None]:  # noqa: PLR0912
     """Execute a command in the operating system and stream its output line by line.
     :param str command: The command to execute.
+    :param dict env: The environment variables to use when executing the command.
     """
     logger.debug(f"Streaming process: {shlex.quote(command)}")
 
     if not sys.stdin.isatty():
         logger.warning("STDIN is not a TTY, running command in non-interactive mode")
-        exec_process = execute(command)
+        exec_process = execute(command, env=env)
 
         if not exec_process:
             yield ""
@@ -164,13 +172,14 @@ def stream(command: str) -> Generator[str, None, None]:  # noqa: PLR0912
     master, slave = pty.openpty()
 
     try:
-        process = Popen(  # noqa: S603
-            shlex.split(command),
+        process = Popen(  # noqa: S602
+            command,
             stdout=slave,
             stderr=slave,
             stdin=slave,
             start_new_session=True,
-            universal_newlines=True,
+            shell=True,
+            env=env,
         )
 
         received_buffer: bytes = b""

odev/common/commands/odoobin.py

@@ -142,6 +142,12 @@ def version(self) -> OdooVersion:
         if self._database.version:
             return self._database.version
 
+        if self._database.exists and not self._database.is_odoo:
+            logger.warning(
+                f"Database {self._database.name!r} is not an Odoo database. Defaulting to 'master'. "
+                f"Consider using 'odev create -V <version> {self._database.name}' to initialize it properly."
+            )
+
         return OdooVersion("master")
 
     @property