fix(core): durcir l auto-install systeme en mode headless non-interactif

Author: raidos23

Core/sys_deps.py

@@ -32,7 +32,10 @@
 
 import platform
 import shutil
+import subprocess
 import webbrowser
+import os
+import time
 from collections.abc import Callable
 from typing import Optional, Union
 
@@ -1083,6 +1086,10 @@ def install_system_packages(packages: list[str], gui=None) -> bool:
     Returns True if successful, False otherwise.
     """
     try:
+        # Mode headless (CLI/CI): ne jamais instancier de widgets Qt.
+        if gui is None:
+            return _install_system_packages_headless(packages)
+
         manager = SysDependencyManager(gui)
         system = platform.system().lower()
 
@@ -1120,3 +1127,104 @@ def install_system_packages(packages: list[str], gui=None) -> bool:
         return False
     except Exception:
         return False
+
+
+def _install_system_packages_headless(packages: list[str]) -> bool:
+    """Install system packages without Qt UI for CLI/CI contexts."""
+    try:
+        pkgs = [str(p).strip() for p in (packages or []) if str(p).strip()]
+        if not pkgs:
+            return True
+
+        system = platform.system().lower()
+        if system != "linux":
+            # Keep behavior explicit for now: only Linux is supported in CI path.
+            return False
+
+        pm = None
+        for candidate in ("apt", "dnf", "yum", "pacman", "zypper"):
+            if shutil.which(candidate):
+                pm = candidate
+                break
+        if not pm:
+            return False
+
+        def _with_privilege(args: list[str]) -> list[str]:
+            try:
+                if hasattr(os, "geteuid") and os.geteuid() == 0:
+                    return list(args)
+            except Exception:
+                pass
+            # CI/CD mode: strictly non-interactive sudo.
+            return ["sudo", "-n"] + list(args)
+
+        steps: list[list[str]]
+        run_env = os.environ.copy()
+        if pm == "apt":
+            # apt-get is more stable than apt for non-interactive automation.
+            run_env["DEBIAN_FRONTEND"] = "noninteractive"
+            steps = [
+                _with_privilege(["apt-get", "-o", "Acquire::Retries=3", "update"]),
+                _with_privilege(
+                    [
+                        "apt-get",
+                        "-o",
+                        "Dpkg::Options::=--force-confdef",
+                        "-o",
+                        "Dpkg::Options::=--force-confnew",
+                        "-o",
+                        "Acquire::Retries=3",
+                        "install",
+                        "-y",
+                        "--no-install-recommends",
+                        *pkgs,
+                    ]
+                ),
+            ]
+        elif pm == "dnf":
+            steps = [_with_privilege(["dnf", "install", "-y", *pkgs])]
+        elif pm == "yum":
+            steps = [_with_privilege(["yum", "install", "-y", *pkgs])]
+        elif pm == "pacman":
+            steps = [
+                _with_privilege(["pacman", "-Sy", "--noconfirm"]),
+                _with_privilege(["pacman", "-S", "--noconfirm", "--needed", *pkgs]),
+            ]
+        else:
+            steps = [
+                _with_privilege(
+                    [
+                        "zypper",
+                        "--non-interactive",
+                        "--gpg-auto-import-keys",
+                        "--no-gpg-checks",
+                        "install",
+                        "-y",
+                        *pkgs,
+                    ]
+                )
+            ]
+
+        for cmd in steps:
+            ok = False
+            # Retry transient failures (network mirrors, temporary locks, etc.).
+            for attempt in range(3):
+                proc = subprocess.run(
+                    cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    timeout=1800,
+                    check=False,
+                    env=run_env,
+                )
+                if proc.returncode == 0:
+                    ok = True
+                    break
+                if attempt < 2:
+                    time.sleep(2)
+            if not ok:
+                return False
+        return True
+    except Exception:
+        return False

OnlyMod/EngineOnlyMod/app.py

@@ -776,7 +776,9 @@ def _ensure_engine_tools_headless(self, engine) -> tuple[bool, str]:
                             return (
                                 False,
                                 "Missing system tools and automatic installation failed: "
-                                + ", ".join(missing_system),
+                                + ", ".join(missing_system)
+                                + ". In CI/headless mode, automatic install is non-interactive for security. "
+                                + "Run the script as root or preinstall required tools.",
                             )
                     except Exception as exc:
                         return (

tests/test_sys_deps_headless.py

@@ -0,0 +1,120 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Ague Samuel Amen
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Headless system dependency installation tests."""
+
+from __future__ import annotations
+
+
+def test_install_system_packages_headless_linux_uses_noninteractive_sudo(
+    monkeypatch,
+) -> None:
+    """Headless mode should run package install commands without Qt widgets."""
+    import Core.sys_deps as sys_deps
+
+    executed: list[list[str]] = []
+
+    class _Result:
+        def __init__(self, returncode: int = 0) -> None:
+            self.returncode = returncode
+            self.stdout = ""
+            self.stderr = ""
+
+    monkeypatch.setattr("platform.system", lambda: "Linux")
+    monkeypatch.setattr(sys_deps.shutil, "which", lambda name: "/usr/bin/apt" if name == "apt" else None)
+    monkeypatch.setattr(sys_deps.os, "geteuid", lambda: 1000, raising=False)
+
+    def _fake_run(cmd, **_kwargs):
+        executed.append(list(cmd))
+        return _Result(0)
+
+    monkeypatch.setattr(sys_deps.subprocess, "run", _fake_run)
+
+    assert sys_deps.install_system_packages(["cloc"], gui=None) is True
+    assert executed == [
+        ["sudo", "-n", "apt-get", "-o", "Acquire::Retries=3", "update"],
+        [
+            "sudo",
+            "-n",
+            "apt-get",
+            "-o",
+            "Dpkg::Options::=--force-confdef",
+            "-o",
+            "Dpkg::Options::=--force-confnew",
+            "-o",
+            "Acquire::Retries=3",
+            "install",
+            "-y",
+            "--no-install-recommends",
+            "cloc",
+        ],
+    ]
+
+
+def test_install_system_packages_headless_does_not_use_qt_manager(monkeypatch) -> None:
+    """Headless mode must bypass the Qt-based SysDependencyManager path."""
+    import Core.sys_deps as sys_deps
+
+    monkeypatch.setattr("platform.system", lambda: "Linux")
+    monkeypatch.setattr(sys_deps.shutil, "which", lambda name: "/usr/bin/dnf" if name == "dnf" else None)
+    monkeypatch.setattr(sys_deps.os, "geteuid", lambda: 0, raising=False)
+    monkeypatch.setattr(
+        sys_deps,
+        "SysDependencyManager",
+        lambda _gui: (_ for _ in ()).throw(AssertionError("Qt manager should not be used in headless mode")),
+    )
+
+    class _Result:
+        def __init__(self, returncode: int = 0) -> None:
+            self.returncode = returncode
+            self.stdout = ""
+            self.stderr = ""
+
+    monkeypatch.setattr(sys_deps.subprocess, "run", lambda *_a, **_k: _Result(0))
+
+    assert sys_deps.install_system_packages(["cloc"], gui=None) is True
+
+
+def test_install_system_packages_headless_retries_transient_failures(monkeypatch) -> None:
+    """Headless install should retry command steps before failing."""
+    import Core.sys_deps as sys_deps
+
+    attempts = {"count": 0}
+
+    class _Result:
+        def __init__(self, returncode: int) -> None:
+            self.returncode = returncode
+            self.stdout = ""
+            self.stderr = ""
+
+    monkeypatch.setattr("platform.system", lambda: "Linux")
+    monkeypatch.setattr(
+        sys_deps.shutil,
+        "which",
+        lambda name: "/usr/bin/dnf" if name == "dnf" else None,
+    )
+    monkeypatch.setattr(sys_deps.os, "geteuid", lambda: 0, raising=False)
+    monkeypatch.setattr(sys_deps.time, "sleep", lambda *_a, **_k: None)
+
+    def _fake_run(_cmd, **_kwargs):
+        attempts["count"] += 1
+        if attempts["count"] == 1:
+            return _Result(1)
+        return _Result(0)
+
+    monkeypatch.setattr(sys_deps.subprocess, "run", _fake_run)
+
+    assert sys_deps.install_system_packages(["cloc"], gui=None) is True
+    assert attempts["count"] == 2