OpenJarvis 1.0.4.dev1025__tar.gz → 1.0.4.dev1027__tar.gz

{openjarvis-1.0.4.dev1025 → openjarvis-1.0.4.dev1027}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: OpenJarvis
-Version: 1.0.4.dev1025
+Version: 1.0.4.dev1027
 Summary: OpenJarvis — modular AI assistant backend with composable intelligence primitives
 Project-URL: Homepage, https://github.com/open-jarvis/OpenJarvis
 Project-URL: Documentation, https://open-jarvis.github.io/OpenJarvis/

{openjarvis-1.0.4.dev1025 → openjarvis-1.0.4.dev1027}/src/openjarvis/mcp/transport.py

@@ -2,9 +2,12 @@
 
 from __future__ import annotations
 
+import json
 import logging
+import queue
 import subprocess
 import threading
+import time
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, List, Optional
 
@@ -62,10 +65,31 @@ class StdioTransport(MCPTransport):
     stdin/stdout.
     """
 
-    def __init__(self, command: List[str]) -> None:
+    _STDOUT_QUEUE_SIZE = 1024
+    _STDOUT_EOF = object()
+
+    def __init__(
+        self,
+        command: List[str],
+        *,
+        response_timeout: float = 600.0,
+    ) -> None:
+        if response_timeout <= 0:
+            raise ValueError("response_timeout must be positive")
         self._command = command
+        self._response_timeout = response_timeout
         self._process: Optional[subprocess.Popen[str]] = None
+        self._stdout_queue: queue.Queue[Any] = queue.Queue(
+            maxsize=self._STDOUT_QUEUE_SIZE
+        )
+        self._reader_stop = threading.Event()
+        self._reader_thread: Optional[threading.Thread] = None
         self._stderr_thread: Optional[threading.Thread] = None
+        # A single stdout stream cannot safely serve multiple independent
+        # readers: one request could consume and discard another request's
+        # response. Serialize complete write/read exchanges (and notification
+        # writes) so response correlation remains lossless.
+        self._request_lock = threading.Lock()
         self._start()
 
     def _start(self) -> None:
@@ -77,17 +101,68 @@ class StdioTransport(MCPTransport):
             stderr=subprocess.PIPE,
             text=True,
         )
+        self._reader_thread = threading.Thread(
+            target=self._read_stdout,
+            name="openjarvis-mcp-stdout",
+            daemon=True,
+        )
+        self._reader_thread.start()
         # Nothing else reads stderr. Once the child writes more than the OS
         # pipe buffer to it, the child blocks on that write and never gets
-        # to answer on stdout, deadlocking send()'s readline() (#750). Drain
-        # it continuously on a background thread instead.
+        # to answer on stdout. Drain it continuously on a background thread.
         self._stderr_thread = threading.Thread(
             target=self._drain_stderr,
             args=(self._process,),
+            name="openjarvis-mcp-stderr",
             daemon=True,
         )
         self._stderr_thread.start()
 
+    def _read_stdout(self) -> None:
+        """Read the subprocess pipe without tying up the request thread.
+
+        A dedicated reader is portable to Windows, where ``select`` cannot
+        wait on an anonymous subprocess pipe. The bounded queue also applies
+        backpressure if a server writes stdout while no request is reading.
+        """
+        proc = self._process
+        stdout = proc.stdout if proc is not None else None
+        if stdout is None:
+            return
+
+        try:
+            while not self._reader_stop.is_set():
+                line = stdout.readline()
+                if not line:
+                    break
+                while not self._reader_stop.is_set():
+                    try:
+                        self._stdout_queue.put(line, timeout=0.1)
+                        break
+                    except queue.Full:
+                        continue
+        finally:
+            while not self._reader_stop.is_set():
+                try:
+                    self._stdout_queue.put(self._STDOUT_EOF, timeout=0.1)
+                    break
+                except queue.Full:
+                    continue
+
+    def _next_stdout_line(self, deadline: float, request_id: Any) -> str:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            raise RuntimeError(f"Timed out waiting for MCP response id {request_id!r}")
+        try:
+            item = self._stdout_queue.get(timeout=remaining)
+        except queue.Empty as exc:
+            raise RuntimeError(
+                f"Timed out waiting for MCP response id {request_id!r}"
+            ) from exc
+        if item is self._STDOUT_EOF:
+            raise RuntimeError("No response from subprocess")
+        return item
+
     def _drain_stderr(self, proc: subprocess.Popen[str]) -> None:
         """Continuously read the child's stderr so its pipe never fills."""
         if proc.stderr is None:
@@ -98,19 +173,45 @@ class StdioTransport(MCPTransport):
                 logger.debug("[%s stderr] %s", self._command[0], line)
 
     def send(self, request: MCPRequest) -> MCPResponse:
-        """Write request as JSON line, read response line."""
-        proc = self._process
-        if proc is None or proc.stdin is None or proc.stdout is None:
-            raise RuntimeError("Transport process is not running")
-
-        line = request.to_json() + "\n"
-        proc.stdin.write(line)
-        proc.stdin.flush()
+        """Write request as JSON line, read lines until the matching response.
 
-        response_line = proc.stdout.readline()
-        if not response_line:
-            raise RuntimeError("No response from subprocess")
-        return MCPResponse.from_json(response_line.strip())
+        MCP servers may emit unsolicited notifications or stray/stale
+        replies on stdout before the real response. Skip anything that
+        isn't a well-formed JSON-RPC response carrying this request's id,
+        rather than treating the first line as gospel (#751).
+        """
+        with self._request_lock:
+            proc = self._process
+            if proc is None or proc.stdin is None or proc.stdout is None:
+                raise RuntimeError("Transport process is not running")
+
+            line = request.to_json() + "\n"
+            proc.stdin.write(line)
+            proc.stdin.flush()
+
+            deadline = time.monotonic() + self._response_timeout
+            while True:
+                # Check the wall-clock deadline even when a server continuously
+                # floods stdout, so queued blank/noise/notification lines cannot
+                # keep extending the request forever.
+                response_line = self._next_stdout_line(deadline, request.id)
+                response_line = response_line.strip()
+                if not response_line:
+                    continue
+
+                try:
+                    parsed = json.loads(response_line)
+                except (json.JSONDecodeError, ValueError):
+                    parsed = None
+
+                is_response = (
+                    isinstance(parsed, dict)
+                    and "id" in parsed
+                    and ("result" in parsed or "error" in parsed)
+                    and parsed["id"] == request.id
+                )
+                if is_response:
+                    return MCPResponse.from_json(response_line)
 
     def send_notification(self, request: MCPRequest) -> None:
         """Send a JSON-RPC notification — write only, never read.
@@ -119,18 +220,36 @@ class StdioTransport(MCPTransport):
         to notifications, so the default ``send()`` would block forever
         on ``proc.stdout.readline()``.
         """
-        proc = self._process
-        if proc is None or proc.stdin is None:
-            raise RuntimeError("Transport process is not running")
-        line = request.to_json() + "\n"
-        proc.stdin.write(line)
-        proc.stdin.flush()
+        with self._request_lock:
+            proc = self._process
+            if proc is None or proc.stdin is None:
+                raise RuntimeError("Transport process is not running")
+            line = request.to_json() + "\n"
+            proc.stdin.write(line)
+            proc.stdin.flush()
 
     def close(self) -> None:
         """Terminate the subprocess."""
         if self._process is not None:
+            self._reader_stop.set()
+            # Wake a request waiting on the queue before stopping the process.
+            try:
+                self._stdout_queue.put_nowait(self._STDOUT_EOF)
+            except queue.Full:
+                try:
+                    self._stdout_queue.get_nowait()
+                    self._stdout_queue.put_nowait(self._STDOUT_EOF)
+                except (queue.Empty, queue.Full):
+                    pass
             self._process.terminate()
-            self._process.wait(timeout=5)
+            try:
+                self._process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+                self._process.wait(timeout=5)
+            if self._reader_thread is not None:
+                self._reader_thread.join(timeout=1)
+                self._reader_thread = None
             self._process = None
         if self._stderr_thread is not None:
             self._stderr_thread.join(timeout=5)

{openjarvis-1.0.4.dev1025 → openjarvis-1.0.4.dev1027}/tests/agents/test_claude_code.py

@@ -83,40 +83,46 @@ class TestEnsureRunner:
             with pytest.raises(RuntimeError, match="Node.js"):
                 agent._ensure_runner()
 
-    def test_creates_runner_dir(self, tmp_path):
+    def test_creates_runner_dir(self, tmp_path, monkeypatch):
         engine = MagicMock()
         engine.engine_id = "mock"
         agent = ClaudeCodeAgent(engine, "test-model")
 
+        # _ensure_runner() resolves its destination via get_config_dir(),
+        # which checks $OPENJARVIS_HOME before ever falling back to
+        # Path.home() -- so that's the env var to control here, not a
+        # Path.home() patch (which get_config_dir() never even calls once
+        # OPENJARVIS_HOME is set, e.g. by conftest.py's session-wide
+        # isolation fixture).
         home_dir = tmp_path / "home"
         home_dir.mkdir()
+        monkeypatch.setenv("OPENJARVIS_HOME", str(home_dir))
 
         with (
             patch("shutil.which", return_value="/usr/bin/node"),
-            patch("pathlib.Path.home", return_value=home_dir),
             patch("subprocess.run") as mock_run,
         ):
             mock_run.return_value = _mock_proc()
-            dest = home_dir / ".openjarvis" / "claude_code_runner"
+            dest = home_dir / "claude_code_runner"
             result = agent._ensure_runner()
             assert result == dest
             mock_run.assert_called_once()
             call_args = mock_run.call_args
             assert "npm" in call_args[0][0][0]
 
-    def test_skips_npm_install_when_node_modules_exists(self, tmp_path):
+    def test_skips_npm_install_when_node_modules_exists(self, tmp_path, monkeypatch):
         engine = MagicMock()
         engine.engine_id = "mock"
         agent = ClaudeCodeAgent(engine, "test-model")
 
         home_dir = tmp_path / "home"
-        dest = home_dir / ".openjarvis" / "claude_code_runner"
+        dest = home_dir / "claude_code_runner"
         dest.mkdir(parents=True)
         (dest / "node_modules").mkdir()
+        monkeypatch.setenv("OPENJARVIS_HOME", str(home_dir))
 
         with (
             patch("shutil.which", return_value="/usr/bin/node"),
-            patch("pathlib.Path.home", return_value=home_dir),
             patch("subprocess.run") as mock_run,
         ):
             agent._ensure_runner()

{openjarvis-1.0.4.dev1025 → openjarvis-1.0.4.dev1027}/tests/conftest.py

@@ -4,14 +4,36 @@ from __future__ import annotations
 
 import json
 import os
+import shutil
+import tempfile
 from pathlib import Path
 from unittest.mock import MagicMock
 
 import pytest
 
-from openjarvis.core.config import GpuInfo, HardwareInfo
-from openjarvis.core.events import EventBus, reset_event_bus
-from openjarvis.core.registry import (
+# Set BEFORE importing openjarvis.core.config: DEFAULT_CONFIG_DIR /
+# DEFAULT_CONFIG_PATH are resolved once at import time (the install-script
+# model, where OPENJARVIS_HOME is set before the process starts). Without
+# this, the very first import of openjarvis.core.config in the session --
+# this file imports it below, and it's transitively imported by nearly
+# everything -- permanently binds those constants (and the ~45 modules that
+# reference them) to the developer's real ~/.openjarvis for the rest of the
+# run, so tests touching e.g. AgentConfigEvolver or LearningOrchestrator
+# read/write real files under the developer's home directory (#787).
+_MISSING = object()
+_ORIGINAL_OPENJARVIS_HOME = os.environ.get("OPENJARVIS_HOME", _MISSING)
+_ORIGINAL_OPENJARVIS_CONFIG = os.environ.get("OPENJARVIS_CONFIG", _MISSING)
+_TEST_HOME = Path(tempfile.mkdtemp(prefix="openjarvis-test-home-"))
+_TEST_HOME_CLEANED = False
+os.environ["OPENJARVIS_HOME"] = str(_TEST_HOME)
+# An explicit config path takes precedence inside load_config(). It may point
+# at a developer's real file even when OPENJARVIS_HOME is isolated, so remove
+# it before config.py and its import-time constants are initialized.
+os.environ.pop("OPENJARVIS_CONFIG", None)
+
+from openjarvis.core.config import GpuInfo, HardwareInfo, load_config  # noqa: E402
+from openjarvis.core.events import EventBus, reset_event_bus  # noqa: E402
+from openjarvis.core.registry import (  # noqa: E402
     AgentRegistry,
     BenchmarkRegistry,
     ChannelRegistry,
@@ -30,6 +52,45 @@ from openjarvis.core.registry import (
 )
 
 
+def _cleanup_test_home() -> None:
+    """Restore import-time process state exactly once.
+
+    A session fixture is not instantiated for ``--collect-only`` and may not
+    be instantiated when collection fails.  Keep the cleanup in a normal
+    function so both fixture teardown and pytest's unconditional unconfigure
+    hook can call it safely.
+    """
+    global _TEST_HOME_CLEANED
+
+    if _TEST_HOME_CLEANED:
+        return
+    _TEST_HOME_CLEANED = True
+
+    load_config.cache_clear()
+    shutil.rmtree(_TEST_HOME, ignore_errors=True)
+
+    if _ORIGINAL_OPENJARVIS_HOME is _MISSING:
+        os.environ.pop("OPENJARVIS_HOME", None)
+    else:
+        os.environ["OPENJARVIS_HOME"] = str(_ORIGINAL_OPENJARVIS_HOME)
+    if _ORIGINAL_OPENJARVIS_CONFIG is _MISSING:
+        os.environ.pop("OPENJARVIS_CONFIG", None)
+    else:
+        os.environ["OPENJARVIS_CONFIG"] = str(_ORIGINAL_OPENJARVIS_CONFIG)
+
+
+def pytest_unconfigure(config: pytest.Config) -> None:
+    """Clean up even when pytest never starts the session fixture."""
+    _cleanup_test_home()
+
+
+@pytest.fixture(scope="session", autouse=True)
+def _cleanup_session_test_home():
+    """Keep the import-time home alive through normal fixture teardown."""
+    yield
+    _cleanup_test_home()
+
+
 @pytest.fixture(autouse=True)
 def _no_update_check(monkeypatch: pytest.MonkeyPatch) -> None:
     """Never let the CLI's PyPI update-check nag run during tests.
@@ -43,6 +104,24 @@ def _no_update_check(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setenv("OPENJARVIS_NO_UPDATE_CHECK", "1")
 
 
+@pytest.fixture(autouse=True)
+def _isolated_openjarvis_home(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Re-assert OPENJARVIS_HOME and clear load_config()'s cache per test.
+
+    Two related leaks (#787): (1) something changing OPENJARVIS_HOME
+    without going through monkeypatch, so it never gets reverted for later
+    tests -- re-asserting it here every test is a cheap defense regardless
+    of cause; (2) load_config()'s functools.lru_cache(maxsize=1) serving a
+    config computed under a *different* test's environment/monkeypatched
+    values instead of the current test's.
+    """
+    monkeypatch.setenv("OPENJARVIS_HOME", str(_TEST_HOME))
+    monkeypatch.delenv("OPENJARVIS_CONFIG", raising=False)
+    load_config.cache_clear()
+    yield
+    load_config.cache_clear()
+
+
 @pytest.fixture(autouse=True)
 def _clean_registries() -> None:
     """Ensure each test starts with empty registries and a fresh event bus."""

{openjarvis-1.0.4.dev1025 → openjarvis-1.0.4.dev1027}/tests/core/test_config_paths.py

@@ -7,6 +7,7 @@ Covers the single-root consolidation: ``$OPENJARVIS_HOME`` >
 
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 import pytest
@@ -174,3 +175,23 @@ class TestLegacyConstantsHonorEnv:
             credentials._default_path()
             == (tmp_path / "oj" / "credentials.toml").resolve()
         )
+
+    def test_constant_never_resolves_to_the_real_developer_home(self) -> None:
+        """Regression for #787: DEFAULT_CONFIG_DIR is resolved once, at the
+        first import of openjarvis.core.config anywhere in the test
+        session -- which happens via tests/conftest.py, before any test
+        body runs. If conftest.py doesn't set OPENJARVIS_HOME before that
+        import, this constant (and the ~45 modules that reference it)
+        permanently binds to the developer's real ~/.openjarvis for the
+        rest of the run, so tests touching e.g. AgentConfigEvolver or
+        LearningOrchestrator read/write real files there.
+
+        No monkeypatching here on purpose: this checks the *actual*
+        session-wide value tests/conftest.py's import-time setup already
+        produced, not a value manufactured by this test.
+        """
+        from openjarvis.core.config import DEFAULT_CONFIG_DIR
+
+        real_home = (Path.home() / ".openjarvis").resolve()
+        assert DEFAULT_CONFIG_DIR != real_home
+        assert "OPENJARVIS_CONFIG" not in os.environ