@opengsd/gsd-pi 1.4.0 → 1.5.0

package/integrations/hermes/open_gsd_hermes/notifications.py

@@ -52,12 +52,21 @@ class NotificationService:
 
     def notify_blocker(self, status: SessionStatus) -> None:
         blocker = status.pending_blocker or {}
-        q = blocker.get("question") or blocker.get("prompt") or "Action required"
+        q = (
+            blocker.get("question")
+            or blocker.get("prompt")
+            or blocker.get("title")
+            or blocker.get("message")
+            or "Action required"
+        )
         self.send(f"🚧 GSD blocker: {q}\nReply with `/gsd reply <your answer>`", kind="blocker")
 
     def notify_transition(self, message: str) -> None:
         self.send(f"📋 GSD: {message}", kind="transition")
 
+    def notify_milestone_complete(self, message: str) -> None:
+        self.send(message, kind="complete")
+
     def notify_terminal(self, status: str, error: str | None = None) -> None:
         normalized_status = status.lower()
         if normalized_status in ("complete", "completed", "done"):

package/integrations/hermes/plugin.yaml

@@ -32,6 +32,10 @@ config_schema:
         cache_ttl_seconds:
           type: integer
           default: 45
+        mcp_read_timeout_seconds:
+          type: number
+          default: 60
+          description: Seconds to wait for one gsd-mcp-server response before resetting the MCP sidecar
         notification_level:
           type: string
           enum: [quiet, normal, verbose]

package/integrations/hermes/tests/test_config.py

@@ -21,6 +21,12 @@ def test_dict_fallback_gsd_version_range_matches_plugin_release_train() -> None:
     assert config.gsd_version_max == "3.0"
 
 
+def test_mcp_read_timeout_can_be_configured() -> None:
+    config = GsdConfig.from_dict({"gsd": {"mcp_read_timeout_seconds": 12.5}})
+
+    assert config.mcp_read_timeout_seconds == 12.5
+
+
 def test_config_path_respects_hermes_home(tmp_path: Path, monkeypatch) -> None:
     monkeypatch.delenv("HERMES_GSD_CONFIG", raising=False)
     monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes-home"))

package/integrations/hermes/tests/test_directory_loader.py

@@ -0,0 +1,37 @@
+"""Directory-loader compatibility tests."""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+
+def load_plugin_directory(plugin_root: Path) -> ModuleType:
+    """Load the Hermes plugin the same way its directory loader does."""
+    init_file = plugin_root / "__init__.py"
+    if not init_file.exists():
+        raise FileNotFoundError(f"No __init__.py in {plugin_root}")
+
+    spec = importlib.util.spec_from_file_location(
+        "open_gsd_hermes_directory_loader",
+        init_file,
+        submodule_search_locations=[str(plugin_root)],
+    )
+    assert spec is not None
+    assert spec.loader is not None
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_plugin_root_supports_hermes_directory_loader() -> None:
+    plugin_root = Path(__file__).resolve().parents[1]
+
+    module = load_plugin_directory(plugin_root)
+
+    assert callable(module.register)
+    assert module.__all__ == ["register"]

package/integrations/hermes/tests/test_gsd_client_cache.py

@@ -70,6 +70,7 @@ def test_progress_falls_back_to_mcp_when_cli_binary_is_missing() -> None:
         "gsd_progress",
         {"projectDir": "/tmp/p"},
         check_version=False,
+        project_dir="/tmp/p",
     )
 
 
@@ -90,6 +91,7 @@ def test_progress_falls_back_to_mcp_when_cli_version_is_unsupported() -> None:
         "gsd_progress",
         {"projectDir": "/tmp/p"},
         check_version=False,
+        project_dir="/tmp/p",
     )
 
 
@@ -117,4 +119,5 @@ def test_progress_falls_back_to_mcp_when_cli_json_has_unexpected_shape() -> None
         "gsd_progress",
         {"projectDir": "/tmp/p"},
         check_version=False,
+        project_dir="/tmp/p",
     )

package/integrations/hermes/tests/test_gsd_client_execute.py

@@ -0,0 +1,35 @@
+"""Unit tests for MCP-backed GSD execution."""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.gsd_client import GsdMcpClient, GsdVersionError
+
+
+def test_execute_falls_back_to_mcp_when_cli_version_is_unsupported() -> None:
+    client = GsdMcpClient(GsdConfig())
+
+    with patch.object(client, "_call_tool") as call_tool:
+        call_tool.side_effect = [
+            GsdVersionError("old gsd"),
+            {"sessionId": "session-1"},
+        ]
+
+        result = client.execute("/tmp/p")
+
+    assert result == {"sessionId": "session-1"}
+    assert call_tool.call_args_list[0].args == (
+        "gsd_execute",
+        {"projectDir": "/tmp/p", "command": "/gsd auto"},
+    )
+    assert call_tool.call_args_list[0].kwargs == {"project_dir": "/tmp/p"}
+    assert call_tool.call_args_list[1].args == (
+        "gsd_execute",
+        {"projectDir": "/tmp/p", "command": "/gsd auto"},
+    )
+    assert call_tool.call_args_list[1].kwargs == {
+        "check_version": False,
+        "project_dir": "/tmp/p",
+    }

package/integrations/hermes/tests/test_gsd_client_process_cwd.py

@@ -0,0 +1,22 @@
+"""Unit tests for MCP server process cwd selection."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.gsd_client import GsdMcpClient
+
+
+def test_ensure_process_starts_server_in_project_cwd(tmp_path) -> None:
+    client = GsdMcpClient(GsdConfig())
+    fake_proc = MagicMock()
+    fake_proc.poll.return_value = None
+
+    with patch.object(client, "_initialize") as initialize:
+        with patch("subprocess.Popen", return_value=fake_proc) as popen:
+            proc = client._ensure_process(str(tmp_path))
+
+    assert proc is fake_proc
+    initialize.assert_called_once_with()
+    assert popen.call_args.kwargs["cwd"] == str(tmp_path)

package/integrations/hermes/tests/test_gsd_client_timeout.py

@@ -0,0 +1,98 @@
+"""Unit tests for MCP stdio read timeouts."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from unittest.mock import patch
+
+import pytest
+
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.gsd_client import GsdMcpClient, McpProtocolError
+
+
+def test_read_message_times_out_waiting_for_headers() -> None:
+    client = GsdMcpClient(GsdConfig(mcp_read_timeout_seconds=0.05))
+    proc = subprocess.Popen(
+        [sys.executable, "-c", "import time; time.sleep(10)"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    client._proc = proc
+
+    try:
+        with pytest.raises(McpProtocolError, match="timed out"):
+            client._read_message()
+        assert client._proc is None
+        assert proc.poll() is not None
+    finally:
+        proc.kill()
+
+
+def test_read_message_times_out_waiting_for_body() -> None:
+    client = GsdMcpClient(GsdConfig(mcp_read_timeout_seconds=0.05))
+    proc = subprocess.Popen(
+        [
+            sys.executable,
+            "-c",
+            (
+                "import sys, time; "
+                "sys.stdout.buffer.write(b'Content-Length: 2\\r\\n\\r\\n{'); "
+                "sys.stdout.flush(); "
+                "time.sleep(10)"
+            ),
+        ],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    client._proc = proc
+
+    try:
+        with pytest.raises(McpProtocolError, match="timed out"):
+            client._read_message()
+        assert client._proc is None
+        assert proc.poll() is not None
+    finally:
+        proc.kill()
+
+
+def test_read_message_fails_without_respawning_when_stdout_closes_mid_body(
+    tmp_path,
+) -> None:
+    client = GsdMcpClient(GsdConfig(mcp_read_timeout_seconds=1))
+    proc = subprocess.Popen(
+        [
+            sys.executable,
+            "-c",
+            (
+                "import sys; "
+                "sys.stdout.buffer.write(b'Content-Length: 20\\r\\n\\r\\n{'); "
+                "sys.stdout.flush()"
+            ),
+        ],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    client._proc = proc
+    client._proc_cwd = str(tmp_path)
+
+    try:
+        with patch.object(
+            client,
+            "_ensure_process",
+            side_effect=AssertionError("read must not respawn MCP server"),
+        ) as ensure_process:
+            with pytest.raises(McpProtocolError, match="closed stdout"):
+                client._read_message()
+
+        ensure_process.assert_not_called()
+        assert client._proc is None
+        assert client._proc_cwd is None
+    finally:
+        if proc.poll() is None:
+            proc.kill()
+        proc.wait(timeout=1)