CI testing - ignore

.github/workflows/ci.yml

@@ -65,6 +65,7 @@ jobs:
 
   tests:
     timeout-minutes: 20
+    if: false
     strategy:
       matrix:
         pyver: ['3.10', '3.11', '3.12', '3.13', '3.14']
@@ -155,12 +156,8 @@ jobs:
             # GitHub Actions only honours `container:` on Linux runners.
             container:
               image: ghcr.io/dimensionalos/ros-dev:dev
-            markers: "self_hosted or skipif_no_ros"
+            markers: "self_hosted or skipif_no_ros or dimsim"
             experimental: false
-          - runner: [self-hosted, macos, arm64]
-            container: null  # run on host — `container:` is Linux-only
-            markers: "self_hosted"
-            experimental: true
     runs-on: ${{ matrix.runner }}
     continue-on-error: ${{ matrix.experimental }}
     permissions:
@@ -231,6 +228,36 @@ jobs:
         with:
           report_type: test_results
           use_oidc: true
+      - name: Dump blueprint logs
+        if: always()
+        shell: bash
+        run: |
+          set +e
+          log_dir="${DIMOS_E2E_LOG_DIR:-/tmp}/dimos-e2e-logs"
+          echo "Looking for blueprint logs in $log_dir"
+          if [ ! -d "$log_dir" ]; then
+            echo "No blueprint log dir present."
+            exit 0
+          fi
+          found=0
+          for f in "$log_dir"/blueprint-*.log; do
+            [ -f "$f" ] || continue
+            found=1
+            echo "::group::$(basename "$f")"
+            cat "$f"
+            echo "::endgroup::"
+          done
+          if [ "$found" = 0 ]; then
+            echo "No blueprint-*.log files found."
+          fi
+      - name: Upload blueprint logs as artifact
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: blueprint-logs
+          path: /tmp/dimos-e2e-logs/
+          if-no-files-found: ignore
+          retention-days: 7
       - name: Check disk space
         if: failure()
         run: |

dimos/e2e_tests/conftest.py

@@ -67,7 +67,7 @@ def fun(*, points: list[tuple[float, float, float]], fail_message: str) -> None:
 
 
 @pytest.fixture
-def start_blueprint(mcp_port: int) -> Iterator[Callable[..., DimosCliCall]]:
+def start_blueprint(mcp_port: int, lcm_spy: LcmSpy) -> Iterator[Callable[..., DimosCliCall]]:
     dimos_robot_call = DimosCliCall()
     dimos_robot_call.mcp_port = mcp_port
 
@@ -79,6 +79,7 @@ def set_name_and_start(
         if simulator is not None:
             dimos_robot_call.simulator = simulator
         dimos_robot_call.start()
+        lcm_spy.register_health_check(dimos_robot_call.check_alive)
         return dimos_robot_call
 
     yield set_name_and_start

dimos/e2e_tests/dimos_cli_call.py

@@ -13,19 +13,32 @@
 # limitations under the License.
 
 import os
+from pathlib import Path
 import signal
 import subprocess
+import sys
+import tempfile
 import time
+from typing import IO
+
+# Blueprint stdio is written under this directory; the CI workflow cats it
+# on failure since pytest's captured output is lost when --timeout-method=thread
+# forces os._exit().
+LOG_DIR = Path(os.environ.get("DIMOS_E2E_LOG_DIR", tempfile.gettempdir())) / "dimos-e2e-logs"
 
 
 class DimosCliCall:
     process: subprocess.Popen[bytes] | None
     demo_args: list[str] | None = None
     mcp_port: int | None = None
     simulator: str = "mujoco"
+    log_path: Path | None
+    _log_file: IO[bytes] | None
 
     def __init__(self) -> None:
         self.process = None
+        self.log_path = None
+        self._log_file = None
 
     def start(self) -> None:
         if self.demo_args is None:
@@ -48,6 +61,19 @@ def start(self) -> None:
                 f"mcpclient.mcp_server_url=http://localhost:{self.mcp_port}/mcp",
             ]
 
+        LOG_DIR.mkdir(parents=True, exist_ok=True)
+        fd, log_path_str = tempfile.mkstemp(prefix="blueprint-", suffix=".log", dir=str(LOG_DIR))
+        os.close(fd)
+        self.log_path = Path(log_path_str)
+        self._log_file = open(self.log_path, "wb")
+        # Print before spawn so the path is in the test log even if the test
+        # later os._exit()s on pytest-timeout.
+        print(f"[dimos blueprint] stdio -> {self.log_path}", file=sys.stderr, flush=True)
+
+        # Force unbuffered Python output in the subprocess so we get lines as
+        # they happen rather than at process exit.
+        env = {**os.environ, "PYTHONUNBUFFERED": "1"}
+
         self.process = subprocess.Popen(
             [
                 "dimos",
@@ -57,9 +83,28 @@ def start(self) -> None:
                 *args,
                 *blueprint_overrides,
             ],
+            stdout=self._log_file,
+            stderr=subprocess.STDOUT,
+            env=env,
             start_new_session=True,
         )
 
+    def check_alive(self) -> None:
+        """Raise if the dimos subprocess has exited.
+
+        Tests block waiting for LCM topics from the blueprint; without this
+        an early crash (missing API key, module init failure) just looks like
+        a 20-minute hang.
+        """
+        if self.process is None:
+            return
+        rc = self.process.poll()
+        if rc is not None:
+            raise RuntimeError(
+                f"dimos blueprint subprocess exited early with code {rc}. "
+                f"See {self.log_path} for output."
+            )
+
     def stop(self) -> None:
         if self.process is None:
             return
@@ -99,3 +144,31 @@ def stop(self) -> None:
                     pass
                 self.process.wait()
             raise
+        finally:
+            self._dump_log()
+
+    def _dump_log(self) -> None:
+        if self._log_file is not None:
+            try:
+                self._log_file.close()
+            except Exception:
+                pass
+            self._log_file = None
+        if self.log_path is None or not self.log_path.exists():
+            return
+        try:
+            content = self.log_path.read_text(errors="replace")
+        except OSError:
+            return
+        if not content.strip():
+            return
+        # Dump to stderr so pytest's "Captured stderr" includes it on failure.
+        # The on-disk copy at log_path remains for CI to cat after job timeout.
+        print(
+            f"\n--- dimos blueprint output ({self.log_path}) ---",
+            file=sys.stderr,
+            flush=True,
+        )
+        sys.stderr.write(content)
+        sys.stderr.write("\n--- end dimos blueprint output ---\n")
+        sys.stderr.flush()

dimos/e2e_tests/lcm_spy.py

@@ -35,6 +35,8 @@ class LcmSpy(LCMService):
     _saved_topics_lock: threading.Lock
     _topic_listeners: dict[str, list[Callable[[bytes], None]]]
     _topic_listeners_lock: threading.Lock
+    _health_checks: list[Callable[[], None]]
+    _health_checks_lock: threading.Lock
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
@@ -45,6 +47,8 @@ def __init__(self, **kwargs: Any) -> None:
         self._saved_topics_lock = threading.Lock()
         self._topic_listeners = {}
         self._topic_listeners_lock = threading.Lock()
+        self._health_checks = []
+        self._health_checks_lock = threading.Lock()
 
     def start(self) -> None:
         super().start()
@@ -89,6 +93,25 @@ def topic_listener(self, topic: str, listener: Callable[[bytes], None]) -> Itera
         finally:
             self.unregister_topic_listener(topic, listener)
 
+    def register_health_check(self, check: Callable[[], None]) -> None:
+        """Register a callable polled during ``wait_until``; it should raise on failure.
+
+        Lets fixtures fail-fast when a supervised subprocess dies, instead of
+        the test blocking on a topic that can never arrive.
+        """
+        with self._health_checks_lock:
+            self._health_checks.append(check)
+
+    def unregister_health_check(self, check: Callable[[], None]) -> None:
+        with self._health_checks_lock:
+            self._health_checks.remove(check)
+
+    def _run_health_checks(self) -> None:
+        with self._health_checks_lock:
+            checks = list(self._health_checks)
+        for check in checks:
+            check()
+
     def wait_until(
         self,
         *,
@@ -99,9 +122,11 @@ def wait_until(
     ) -> None:
         start_time = time.time()
         while time.time() - start_time < timeout:
+            self._run_health_checks()
             if condition():
                 return
             time.sleep(poll_interval)
+        self._run_health_checks()
         raise TimeoutError(error_message)
 
     def wait_for_saved_topic(self, topic: str, timeout: float = 30.0) -> None:

dimos/e2e_tests/test_dimsim_path_replaning.py

@@ -16,6 +16,7 @@
 
 
 @pytest.mark.dimsim
+@pytest.mark.skipif_no_openai
 def test_path_replanning(
     lcm_spy, start_blueprint, dim_sim, direct_cmd_vel_explorer, spawn_wall_on_pose
 ) -> None:

dimos/e2e_tests/test_dimsim_spatial_memory.py

@@ -16,6 +16,7 @@
 
 
 @pytest.mark.dimsim
+@pytest.mark.skipif_no_openai
 def test_go_to_the_bed(lcm_spy, start_blueprint, human_input, dim_sim, explore_house) -> None:
     start_blueprint(
         "run",

dimos/e2e_tests/test_dimsim_walk_forward.py

@@ -16,6 +16,7 @@
 
 
 @pytest.mark.dimsim
+@pytest.mark.skipif_no_openai
 def test_walk_forward(lcm_spy, start_blueprint, human_input, dim_sim) -> None:
     start_blueprint(
         "run",