fix: new config format now activates container execution (#14, #15)

Root cause: use_container was only checked via legacy env_type=='container',
but the new config format (env.backend / env.workspace_mode) never sets
env_type, so container execution was never activated.

Changes:
- Add EnvConfig.wants_container property that bridges legacy and new
  config formats. Returns True when env_type=='container' (legacy),
  backend is explicitly set (new), or workspace_mode requires a
  container volume (sync/copy/tmpfs).
- Replace all env_type=='container' checks in env.py with
  cfg.wants_container (do_run, _doctor, _benchmark).
- Add robust error handling to _sync: validates engine is in PATH
  and responsive before attempting container operations. Wraps
  docker cp/volume operations in try/except with actionable error
  messages instead of silent crashes.
- Add 6 unit tests for wants_container covering legacy, new format,
  explicit backend, sync mode, bind mode, and empty config.

Fixes #14 — west env sync no longer crashes silently
Fixes #15 — west env build now uses container when new config format used

Co-Authored-By: Oz <oz-agent@warp.dev>

Author: tbitcs

tests/test_config.py

@@ -100,5 +100,48 @@ def test_load_config_handles_empty_file(self):
             self.assertIsNone(cfg.image)
 
 
+    def test_wants_container_legacy_container(self):
+        """Legacy env.type=container should set wants_container=True."""
+        from west_env.config import EnvConfig
+
+        cfg = EnvConfig({"env": {"type": "container", "container": {"engine": "docker"}}})
+        self.assertTrue(cfg.wants_container)
+
+    def test_wants_container_legacy_native(self):
+        """Legacy env.type=native with no backend should set wants_container=False."""
+        from west_env.config import EnvConfig
+
+        cfg = EnvConfig({"env": {"type": "native"}})
+        self.assertFalse(cfg.wants_container)
+
+    def test_wants_container_new_format_explicit_backend(self):
+        """New format with explicit backend should set wants_container=True."""
+        from west_env.config import EnvConfig
+
+        cfg = EnvConfig({"env": {"backend": "docker-desktop"}})
+        self.assertTrue(cfg.wants_container)
+
+    def test_wants_container_new_format_sync_mode(self):
+        """New format with workspace_mode=sync implies container execution."""
+        from west_env.config import EnvConfig
+
+        cfg = EnvConfig({"env": {"backend": "auto", "workspace_mode": "sync"}})
+        self.assertTrue(cfg.wants_container)
+
+    def test_wants_container_new_format_bind_mode_auto(self):
+        """New format with workspace_mode=bind and auto backend is native."""
+        from west_env.config import EnvConfig
+
+        cfg = EnvConfig({"env": {"backend": "auto", "workspace_mode": "bind"}})
+        self.assertFalse(cfg.wants_container)
+
+    def test_wants_container_empty_config(self):
+        """Empty config should not want container."""
+        from west_env.config import EnvConfig
+
+        cfg = EnvConfig({})
+        self.assertFalse(cfg.wants_container)
+
+
 if __name__ == "__main__":
     unittest.main()

west_commands/env.py

@@ -152,7 +152,7 @@ def do_add_parser(self, parser_adder):
 
     def do_run(self, args, unknown_args):
         cfg = load_config(self.topdir)
-        use_container = args.container or cfg.env_type == "container"
+        use_container = args.container or cfg.wants_container
         passthrough = [a for a in args.args if a not in ("--container",)]
         passthrough.extend(a for a in unknown_args if a not in ("--container",))
 
@@ -270,12 +270,15 @@ def _doctor(self, cfg, use_container):
         except Exception:
             pass
 
-        # Legacy container checks (kept for test compatibility)
+        # Container checks
         if use_container:
             ok &= check_container(cfg)
             ok &= self._doctor_container_workspace(cfg)
         else:
-            print("\n[INFO] container execution disabled")
+            if cfg.wants_container:
+                print("\n[INFO] container execution enabled (new config format)")
+            else:
+                print("\n[INFO] container execution disabled")
 
         print()
         if ok:
@@ -300,22 +303,67 @@ def _doctor_container_workspace(self, cfg):
 
     def _sync(self, cfg, mode, back=False):
         from west_env.sync import WorkspaceSync, _workspace_slug
+        import subprocess
+        from shutil import which
 
         topdir = Path(self.topdir).resolve()
         ws = WorkspaceSync(workspace_mode=mode)
         engine_name = self._engine_name(cfg)
         volume = f"west-env-ws-{_workspace_slug(topdir)}"
 
+        # Validate engine is available before attempting any container ops
+        if not which(engine_name):
+            raise SystemExit(
+                f"FATAL: '{engine_name}' not found in PATH.\n"
+                f"  Install Docker or Podman, or check your PATH.\n"
+                f"  Run 'west env doctor' for diagnostics."
+            )
+
+        # Verify engine is responsive
+        try:
+            subprocess.check_output(
+                [engine_name, "info"],
+                stderr=subprocess.DEVNULL,
+                timeout=15,
+            )
+        except subprocess.TimeoutExpired:
+            raise SystemExit(
+                f"FATAL: '{engine_name} info' timed out.\n"
+                f"  Is the Docker/Podman daemon running?"
+            )
+        except (subprocess.CalledProcessError, FileNotFoundError) as exc:
+            raise SystemExit(
+                f"FATAL: '{engine_name} info' failed: {exc}\n"
+                f"  Is the Docker/Podman daemon running?\n"
+                f"  Run 'west env doctor' for diagnostics."
+            )
+
         if back:
             print(f"Syncing artifacts back from container (mode={mode})...")
             artifacts_dir = topdir / "artifacts"
-            ws.sync_from_volume(engine_name, volume, artifacts_dir)
+            try:
+                ws.sync_from_volume(engine_name, volume, artifacts_dir)
+            except subprocess.CalledProcessError as exc:
+                raise SystemExit(
+                    f"FATAL: artifact sync failed (exit {exc.returncode}).\n"
+                    f"  Volume: {volume}\n"
+                    f"  Ensure you have run 'west env sync' and built at least once."
+                )
             print(f"[OK] artifacts written to {artifacts_dir}")
         else:
             print(f"Syncing source to container (mode={mode})...")
             ws.warn_if_needed()
             if mode in ("sync", "copy", "tmpfs"):
-                ws.sync_to_volume(topdir, engine_name, volume)
+                try:
+                    ws.sync_to_volume(topdir, engine_name, volume)
+                except subprocess.CalledProcessError as exc:
+                    raise SystemExit(
+                        f"FATAL: source sync failed (exit {exc.returncode}).\n"
+                        f"  Engine: {engine_name}\n"
+                        f"  Volume: {volume}\n"
+                        f"  Ensure the container runtime is running and the\n"
+                        f"  'alpine' image is available (run: {engine_name} pull alpine)."
+                    )
                 print(f"[OK] source synced to volume {volume}")
             else:
                 print("[INFO] bind mode: no sync needed; host path mounted directly")
@@ -375,7 +423,7 @@ def _benchmark(self, cfg, passthrough):
         start = time.monotonic()
         cmd = ["west", "build", "-b", board] + ([sample] if sample else [])
         try:
-            if cfg.env_type == "container":
+            if cfg.wants_container:
                 self._run_container(cfg, cmd)
             else:
                 run_host(cmd)

west_env/config.py

@@ -113,6 +113,26 @@ def __init__(self, data):
         if self.jlink_mode not in {"host", "tcp-server", "none"}:
             raise ValueError(f"unsupported jlink.mode: {self.jlink_mode}")
 
+    @property
+    def wants_container(self) -> bool:
+        """Return True if config implies container-backed execution.
+
+        The new config format (env.backend / env.workspace_mode) does not
+        set ``env.type`` to ``"container"``.  This property bridges the
+        gap so callers don't have to know about both code paths.
+        """
+        # Legacy explicit container mode
+        if self.env_type == "container":
+            return True
+        # New format: explicit non-native backend
+        if self.backend not in (None, "auto"):
+            return True
+        # New format with auto backend: workspace modes that require a
+        # container volume imply container execution
+        if self.workspace_mode in ("sync", "copy", "tmpfs"):
+            return True
+        return False
+
 
 def find_config_path(topdir=None):
     if topdir is None: