bcasl: corriger ouverture du loader et eviter les doubles lancements

- fixe l'import de dialogue BCASL avec fallback robuste

- garantit une connexion unique du bouton BC en mode IDE

- ajoute un fallback de decouverte des plugins pour eviter les tabs vides

Author: raidos23

Core/IdeLikeGui/connections.py

@@ -418,6 +418,28 @@ def _open_theme_dialog(self) -> None:
     _apply_activity_buttons_theme(self)
 
 
+def _open_bcasl_loader(self) -> None:
+    """Open BCASL dialog with a resilient runtime import path."""
+    try:
+        from importlib import import_module
+
+        mod = import_module("bcasl.Loader")
+        fn = getattr(mod, "open_bc_loader_dialog", None)
+        if callable(fn):
+            fn(self)
+            return
+    except Exception:
+        pass
+    try:
+        import bcasl
+
+        fn2 = getattr(bcasl, "open_api_loader_dialog", None)
+        if callable(fn2):
+            fn2(self)
+    except Exception:
+        pass
+
+
 def _apply_activity_buttons_theme(self) -> None:
     """Ensure activity-bar tool buttons follow current app theme."""
     try:
@@ -493,6 +515,15 @@ def _connect_ide_like_signals(self) -> None:
             self.btn_nuitka_icon.clicked.connect(self.select_nuitka_icon)
     except Exception:
         pass
+    try:
+        if getattr(self, "btn_bc_loader", None):
+            try:
+                self.btn_bc_loader.clicked.disconnect()
+            except Exception:
+                pass
+            self.btn_bc_loader.clicked.connect(lambda: _open_bcasl_loader(self))
+    except Exception:
+        pass
 
     _bind_status_updates(self)
 

Core/UiConnection.py

@@ -554,9 +554,29 @@ def _connect_text(widget, handler) -> None:
 
     if self.btn_bc_loader:
         try:
-            from bcasl import open_bc_loader_dialog
+            from importlib import import_module
 
-            self.btn_bc_loader.clicked.connect(lambda: open_bc_loader_dialog(self))
+            def _open_bc():
+                try:
+                    # Preferred rich BCASL dialog (plugin config tabs).
+                    mod = import_module("bcasl.Loader")
+                    fn = getattr(mod, "open_bc_loader_dialog", None)
+                    if callable(fn):
+                        fn(self)
+                        return
+                except Exception:
+                    pass
+                try:
+                    # Fallback to exported API loader.
+                    import bcasl
+
+                    fn2 = getattr(bcasl, "open_api_loader_dialog", None)
+                    if callable(fn2):
+                        fn2(self)
+                except Exception:
+                    pass
+
+            self.btn_bc_loader.clicked.connect(_open_bc)
         except Exception:
             pass
 

bcasl/Loader.py

@@ -193,6 +193,74 @@ def _discover_bcasl_plugins(
                 continue
     except Exception:
         pass
+
+    # Fallback robuste: import package par package et collecte des classes @bc_register
+    # si le chargement standard n'a rien retourné.
+    if plugins:
+        return plugins
+    try:
+        import importlib.util as _ilu
+        import sys as _sys
+
+        for pkg_dir in sorted(Plugins_dir.iterdir(), key=lambda p: p.name):
+            try:
+                if not pkg_dir.is_dir():
+                    continue
+                init_py = pkg_dir / "__init__.py"
+                if not init_py.exists():
+                    continue
+                mod_name = f"bcasl_fallback_{pkg_dir.name}"
+                spec = _ilu.spec_from_file_location(
+                    mod_name, str(init_py), submodule_search_locations=[str(pkg_dir)]
+                )
+                if spec is None or spec.loader is None:
+                    continue
+                module = _ilu.module_from_spec(spec)
+                _sys.modules[mod_name] = module
+                spec.loader.exec_module(module)  # type: ignore[attr-defined]
+
+                # Support ancien style: bcasl_register(manager)
+                try:
+                    reg = getattr(module, "bcasl_register", None)
+                    if callable(reg):
+                        mgr = BCASL(
+                            workspace_root,
+                            config=cfg,
+                            sandbox=False,
+                            plugin_timeout_s=0.0,
+                        )
+                        reg(mgr)
+                        for pid, rec in getattr(mgr, "_registry", {}).items():
+                            try:
+                                plugins[str(pid)] = rec.plugin
+                            except Exception:
+                                continue
+                except Exception:
+                    pass
+
+                # Support style décorateur: classes marquées @bc_register
+                for attr_name in dir(module):
+                    try:
+                        attr = getattr(module, attr_name, None)
+                        if attr is None or not isinstance(attr, type):
+                            continue
+                        if not getattr(attr, "__bcasl_plugin__", False):
+                            continue
+                        inst = getattr(attr, "_bcasl_instance_", None)
+                        if inst is None:
+                            try:
+                                inst = attr()
+                            except Exception:
+                                continue
+                        pid = getattr(getattr(inst, "meta", None), "id", None)
+                        if isinstance(pid, str) and pid and pid not in plugins:
+                            plugins[pid] = inst
+                    except Exception:
+                        continue
+            except Exception:
+                continue
+    except Exception:
+        pass
     return plugins