hud-python 0.4.36__py3-none-any.whl → 0.4.38__py3-none-any.whl

hud/server/tests/test_mcp_server_more.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import asyncio
+import socket
+from contextlib import asynccontextmanager, suppress
+
+import anyio
+import pytest
+
+from hud.clients import MCPClient
+from hud.server import MCPServer
+from hud.server import server as server_mod  # to toggle _sigterm_received
+
+
+def _free_port() -> int:
+    """Get a free port for testing."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+@asynccontextmanager
+async def _fake_stdio_server():
+    """
+    Stand-in for mcp.server.stdio.stdio_server that avoids reading real stdin.
+
+    It yields a pair of in-memory streams (receive, send) so the low-level server
+    can start and idle without touching sys.stdin/sys.stdout.
+    """
+    # Server reads from recv_in and writes to send_out
+    send_in, recv_in = anyio.create_memory_object_stream(100)  # stdin → server
+    send_out, recv_out = anyio.create_memory_object_stream(100)  # server → stdout
+    try:
+        yield recv_in, send_out
+    finally:
+        # Best effort close; methods exist across anyio versions
+        for s in (send_in, recv_in, send_out, recv_out):
+            close = getattr(s, "close", None) or getattr(s, "aclose", None)
+            try:
+                if close is not None:
+                    res = close()
+                    if asyncio.iscoroutine(res):
+                        await res
+            except Exception:
+                pass
+
+
+@pytest.fixture(autouse=True)
+def _patch_stdio(monkeypatch: pytest.MonkeyPatch):
+    """Patch stdio server for all tests to avoid stdin reading issues."""
+    monkeypatch.setenv("FASTMCP_DISABLE_BANNER", "1")
+    # Patch both the source and the bound symbol FastMCP uses
+    monkeypatch.setattr("mcp.server.stdio.stdio_server", _fake_stdio_server)
+    monkeypatch.setattr("fastmcp.server.server.stdio_server", _fake_stdio_server)
+
+
+@pytest.mark.asyncio
+async def test_stdio_shutdown_handler_on_sigterm_flag() -> None:
+    """@mcp.shutdown runs on stdio transport when the SIGTERM flag is set."""
+    mcp = MCPServer(name="StdIOShutdown")
+    calls = {"n": 0}
+
+    @mcp.shutdown
+    async def _on_shutdown() -> None:
+        calls["n"] += 1
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        # Simulate SIGTERM path
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    assert calls["n"] == 1
+    assert not getattr(server_mod, "_sigterm_received")
+
+
+@pytest.mark.asyncio
+async def test_stdio_shutdown_handler_not_called_without_sigterm() -> None:
+    """@mcp.shutdown must NOT run on stdio cancel when no SIGTERM flag."""
+    mcp = MCPServer(name="StdIONoSigterm")
+    called = {"n": 0}
+
+    @mcp.shutdown
+    async def _on_shutdown() -> None:
+        called["n"] += 1
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        # no SIGTERM flag
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    assert called["n"] == 0
+
+
+@pytest.mark.asyncio
+async def test_last_initialize_handler_wins_and_ctx_shape_exists() -> None:
+    """If multiple @initialize decorators are applied, only the last one should execute.
+    Also sanity-check that ctx has the expected core attributes in a version-tolerant way.
+    """
+    port = _free_port()
+
+    mcp = MCPServer(name="InitOverride")
+    seen = {"a": False, "b": False, "has_session": False, "has_request": False}
+
+    @mcp.initialize
+    async def _init_a(ctx) -> None:  # type: ignore[override]
+        # This one should get overridden and never run
+        seen["a"] = True
+
+    @mcp.initialize
+    async def _init_b(ctx) -> None:  # type: ignore[override]
+        # This is the one that should actually run
+        seen["b"] = True
+        seen["has_session"] = hasattr(ctx, "session") and ctx.session is not None
+        seen["has_request"] = hasattr(ctx, "request") and ctx.request is not None
+
+    # A simple echo tool so we can verify the server works post-init
+    @mcp.tool()
+    async def echo(text: str = "ok") -> str:  # type: ignore[override]
+        return f"echo:{text}"
+
+    # Start HTTP transport (quickest way to use a real client)
+    task = asyncio.create_task(
+        mcp.run_async(
+            transport="http",
+            host="127.0.0.1",
+            port=port,
+            path="/mcp",
+            log_level="ERROR",
+            show_banner=False,
+        )
+    )
+    await asyncio.sleep(0.05)
+
+    try:
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        c = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c.initialize()
+
+        # Call a tool to ensure init didn't break anything
+        res = await c.call_tool(name="echo", arguments={"text": "ping"})
+        text = getattr(res, "content", None)
+        if isinstance(text, list) and text and hasattr(text[0], "text"):
+            text = text[0].text
+        assert text == "echo:ping"
+
+        await c.shutdown()
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    # Only the last initializer should have run
+    assert seen["a"] is False
+    assert seen["b"] is True
+    # And the ctx had the key attributes (shape may vary by lib version; just presence)
+    assert seen["has_session"] is True
+    assert seen["has_request"] is True
+
+
+@pytest.mark.asyncio
+async def test_stdio_shutdown_handler_runs_once_when_both_paths_fire() -> None:
+    """Even on stdio, when SIGTERM is set, ensure shutdown runs exactly once."""
+    mcp = MCPServer(name="StdIOOnce")
+    calls = {"n": 0}
+
+    @mcp.shutdown
+    async def _on_shutdown() -> None:
+        calls["n"] += 1
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        # Make both the lifespan.finally and run_async.finally want to execute
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    assert calls["n"] == 1
+    # Reset global flag always
+    server_mod._sigterm_received = False  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_run_async_defaults_to_stdio_and_uses_patched_stdio(monkeypatch: pytest.MonkeyPatch):
+    """transport=None should default to stdio and use our patched stdio server."""
+    entered = {"v": False}
+
+    @asynccontextmanager
+    async def tracking_stdio():
+        entered["v"] = True
+        async with _fake_stdio_server() as streams:
+            yield streams
+
+    # Override the autouse fixture for this test to track entry
+    monkeypatch.setattr("fastmcp.server.server.stdio_server", tracking_stdio)
+
+    mcp = MCPServer(name="DefaultStdio")
+    task = asyncio.create_task(mcp.run_async(transport=None, show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        assert entered["v"] is True, "Expected stdio transport to be used by default"
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+
+@pytest.mark.asyncio
+async def test_custom_lifespan_relies_on_run_async_fallback_for_sigterm() -> None:
+    """When a custom lifespan is supplied, run_async's finally path must still call
+    @shutdown on SIGTERM."""
+
+    @asynccontextmanager
+    async def custom_lifespan(_):
+        # No shutdown call here on purpose
+        yield {}
+
+    mcp = MCPServer(name="CustomLS", lifespan=custom_lifespan)
+    calls = {"n": 0}
+
+    @mcp.shutdown
+    async def _s() -> None:
+        calls["n"] += 1
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        # Ensure finalizer believes SIGTERM happened
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    assert calls["n"] == 1
+    assert not getattr(server_mod, "_sigterm_received")

hud/server/tests/test_run_wrapper.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from hud.server import MCPServer
+
+if TYPE_CHECKING:
+    import pytest
+
+
+def test_run_uses_sigterm_wrapper(monkeypatch: pytest.MonkeyPatch) -> None:
+    """MCPServer.run should delegate through _run_with_sigterm (don't actually start a server)."""
+    called = {"hit": False, "args": None, "kwargs": None}
+
+    def fake_wrapper(coro_fn, *args, **kwargs):
+        called["hit"] = True
+        called["args"] = args
+        called["kwargs"] = kwargs
+        # Do not execute the bootstrap coroutine; this is unit wiring only.
+
+    monkeypatch.setattr("hud.server.server._run_with_sigterm", fake_wrapper)
+
+    mcp = MCPServer(name="RunWrapper")
+    # Should immediately return after calling our fake wrapper
+    mcp.run(transport="http", host="127.0.0.1", port=9999, path="/mcp", show_banner=False)
+
+    assert called["hit"] is True
+
+
+def test_run_defaults_to_stdio(monkeypatch: pytest.MonkeyPatch) -> None:
+    """transport=None in .run should resolve to 'stdio' and forward to run_async."""
+    seen = {}
+
+    async def fake_run_async(self, *, transport, show_banner, **kwargs):
+        seen["transport"] = transport
+        seen["show_banner"] = show_banner
+        seen["kwargs"] = kwargs
+
+    # Replace bound method on the instance class
+    monkeypatch.setattr(MCPServer, "run_async", fake_run_async, raising=False)
+
+    # Execute the bootstrap coroutine immediately (no real server)
+    def fake_wrapper(coro_fn, *args, **kwargs):
+        asyncio.run(coro_fn())
+
+    monkeypatch.setattr("hud.server.server._run_with_sigterm", fake_wrapper)
+
+    mcp = MCPServer(name="RunDefaultTransport")
+    mcp.run(transport=None, show_banner=False)
+
+    assert seen["transport"] == "stdio"
+    assert seen["show_banner"] is False

hud/server/tests/test_server_extra.py

@@ -0,0 +1,166 @@
+# filename: hud/server/tests/test_server_extra.py
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager, suppress
+
+import anyio
+import pytest
+
+from hud.server import MCPServer
+from hud.server import server as server_mod
+
+
+@asynccontextmanager
+async def _fake_stdio_server():
+    """
+    Stand-in for stdio_server that avoids reading real stdin.
+
+    It yields a pair of in-memory streams (receive, send) so the low-level server
+    can start and idle without touching sys.stdin/sys.stdout.
+    """
+    send_in, recv_in = anyio.create_memory_object_stream(100)
+    send_out, recv_out = anyio.create_memory_object_stream(100)
+    try:
+        yield recv_in, send_out
+    finally:
+        # best-effort close across anyio versions
+        for s in (send_in, recv_in, send_out, recv_out):
+            close = getattr(s, "close", None) or getattr(s, "aclose", None)
+            try:
+                if close is not None:
+                    res = close()
+                    if asyncio.iscoroutine(res):
+                        await res
+            except Exception:
+                pass
+
+
+@pytest.fixture
+def patch_stdio(monkeypatch: pytest.MonkeyPatch):
+    """Patch stdio server to avoid stdin issues during tests."""
+    monkeypatch.setenv("FASTMCP_DISABLE_BANNER", "1")
+    monkeypatch.setattr("mcp.server.stdio.stdio_server", _fake_stdio_server)
+    monkeypatch.setattr("fastmcp.server.server.stdio_server", _fake_stdio_server)
+
+
+@pytest.mark.asyncio
+async def test_sigterm_flag_remains_true_without_shutdown_handler(patch_stdio):
+    """
+    When no @mcp.shutdown is registered, neither the lifespan.finally nor run_async.finally
+    should reset the global SIGTERM flag. This exercises the 'no handler' branches.
+    """
+    mcp = MCPServer(name="NoShutdownHandler")
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        # Simulate SIGTERM path
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    # Flag must remain set since no shutdown handler was installed
+    assert getattr(server_mod, "_sigterm_received") is True
+
+    # Always reset for other tests
+    server_mod._sigterm_received = False  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_last_shutdown_handler_wins(patch_stdio):
+    """
+    If multiple @mcp.shutdown decorators are applied, the last one should be the one that runs.
+    """
+    mcp = MCPServer(name="ShutdownOverride")
+    calls: list[str] = []
+
+    @mcp.shutdown
+    async def _first() -> None:
+        calls.append("first")
+
+    @mcp.shutdown
+    async def _second() -> None:
+        calls.append("second")
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    assert calls == ["second"], "Only the last registered shutdown handler should run"
+    server_mod._sigterm_received = False  # type: ignore[attr-defined]
+
+
+def test__run_with_sigterm_registers_handlers_when_enabled(monkeypatch: pytest.MonkeyPatch):
+    """
+    Verify that _run_with_sigterm attempts to register SIGTERM/SIGINT handlers
+    when the env var does NOT disable the handler. We stub AnyIO's TaskGroup so
+    the watcher doesn't block and the test returns immediately.
+    """
+    # Ensure handler is enabled
+    monkeypatch.delenv("FASTMCP_DISABLE_SIGTERM_HANDLER", raising=False)
+
+    # Record what the server tries to register
+    added_signals: list[int] = []
+
+    import asyncio as _asyncio
+
+    orig_get_running_loop = _asyncio.get_running_loop
+
+    def proxy_get_running_loop():
+        real = orig_get_running_loop()
+
+        class _LoopProxy:
+            __slots__ = ("_inner",)
+
+            def __init__(self, inner):
+                self._inner = inner
+
+            def add_signal_handler(self, signum, callback, *args):
+                added_signals.append(signum)  # don't actually install
+                # no-op: skip calling inner.add_signal_handler to avoid OS constraints
+
+            def __getattr__(self, name):
+                # delegate everything else (create_task, call_soon, etc.)
+                return getattr(self._inner, name)
+
+        return _LoopProxy(real)
+
+    # Patch globally so both the test and hud.server.server see the proxy
+    monkeypatch.setattr(_asyncio, "get_running_loop", proxy_get_running_loop)
+
+    # Dummy TaskGroup that runs the work but skips _watch
+    class _DummyTG:
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, exc_type, exc, tb):
+            return False
+
+        def start_soon(self, fn, *args, **kwargs):
+            if getattr(fn, "__name__", "") == "_watch":
+                return
+            _asyncio.get_running_loop().create_task(fn(*args, **kwargs))
+
+    monkeypatch.setattr("anyio.create_task_group", lambda: _DummyTG())
+
+    # Simple coroutine that should run to completion
+    hit = {"v": False}
+
+    async def work():
+        hit["v"] = True
+
+    server_mod._run_with_sigterm(work)
+    assert hit["v"] is True
+
+    import signal as _signal
+
+    assert _signal.SIGTERM in added_signals
+    assert _signal.SIGINT in added_signals

hud/server/tests/test_sigterm_runner.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager, suppress
+
+import anyio
+import pytest
+
+from hud.server import MCPServer
+from hud.server import server as server_mod
+
+
+def test__run_with_sigterm_executes_coro_when_handler_disabled(monkeypatch: pytest.MonkeyPatch):
+    """With FASTMCP_DISABLE_SIGTERM_HANDLER=1, _run_with_sigterm should just run the task."""
+    monkeypatch.setenv("FASTMCP_DISABLE_SIGTERM_HANDLER", "1")
+
+    hit = {"v": False}
+
+    async def work(arg, *, kw=None):
+        assert arg == 123 and kw == "ok"
+        hit["v"] = True
+
+    # Wrapper to exercise kwargs since TaskGroup.start_soon only accepts positional args
+    async def wrapper(arg):
+        await work(arg, kw="ok")
+
+    # Should return cleanly and mark hit
+    server_mod._run_with_sigterm(wrapper, 123)
+    assert hit["v"] is True
+
+
+@asynccontextmanager
+async def _fake_stdio_server():
+    """Stand-in for stdio_server that avoids reading real stdin."""
+    send_in, recv_in = anyio.create_memory_object_stream(100)
+    send_out, recv_out = anyio.create_memory_object_stream(100)
+    try:
+        yield recv_in, send_out
+    finally:
+        for s in (send_in, recv_in, send_out, recv_out):
+            close = getattr(s, "close", None) or getattr(s, "aclose", None)
+            try:
+                if close is not None:
+                    res = close()
+                    if asyncio.iscoroutine(res):
+                        await res
+            except Exception:
+                pass
+
+
+@pytest.fixture
+def patch_stdio(monkeypatch: pytest.MonkeyPatch):
+    """Patch stdio server to avoid stdin issues during tests."""
+    monkeypatch.setenv("FASTMCP_DISABLE_BANNER", "1")
+    monkeypatch.setattr("mcp.server.stdio.stdio_server", _fake_stdio_server)
+    monkeypatch.setattr("fastmcp.server.server.stdio_server", _fake_stdio_server)
+
+
+@pytest.mark.asyncio
+async def test_shutdown_handler_exception_does_not_crash_and_resets_flag(patch_stdio):
+    """If @shutdown raises, run_async must swallow it and still reset the SIGTERM flag."""
+    mcp = MCPServer(name="ShutdownRaises")
+
+    @mcp.shutdown
+    async def _boom() -> None:
+        raise RuntimeError("kaboom")
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        server_mod._sigterm_received = True  # trigger shutdown path
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    # No exception propagated; flag must be reset
+    assert not getattr(server_mod, "_sigterm_received")

hud/shared/hints.py

@@ -38,7 +38,7 @@ HUD_API_KEY_MISSING = Hint(
     message="Missing or invalid HUD_API_KEY.",
     tips=[
         "Set HUD_API_KEY in your environment or run: hud set HUD_API_KEY=your-key-here",
-        "Get a key at https://app.hud.so",
+        "Get a key at https://hud.so",
         "Check for whitespace or truncation",
     ],
     docs_url=None,

hud/telemetry/job.py

@@ -143,7 +143,7 @@ def _print_job_url(job_id: str, job_name: str) -> None:
     if not (settings.telemetry_enabled and settings.api_key):
         return
 
-    url = f"https://app.hud.so/jobs/{job_id}"
+    url = f"https://hud.so/jobs/{job_id}"
     header = f"🚀 Job '{job_name}' started:"
 
     # ANSI color codes
@@ -182,7 +182,7 @@ def _print_job_complete_url(job_id: str, job_name: str, error_occurred: bool = F
     if not (settings.telemetry_enabled and settings.api_key):
         return
 
-    url = f"https://app.hud.so/jobs/{job_id}"
+    url = f"https://hud.so/jobs/{job_id}"
 
     # ANSI color codes
     GREEN = "\033[92m"

hud/types.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import json
 import logging
 import uuid
@@ -107,7 +108,13 @@ class Task(BaseModel):
 
         # Start with current environment variables
         mapping = dict(os.environ)
-        mapping.update(settings.model_dump())
+        # Include settings (from process env, project .env, and user .env)
+        settings_dict = settings.model_dump()
+        mapping.update(settings_dict)
+        # Add UPPERCASE aliases for settings keys
+        for _key, _val in settings_dict.items():
+            with contextlib.suppress(Exception):
+                mapping[_key.upper()] = _val
 
         if settings.api_key:
             mapping["HUD_API_KEY"] = settings.api_key
@@ -208,7 +215,7 @@ class AgentResponse(BaseModel):
     tool_calls: list[MCPToolCall] = Field(default_factory=list)
     done: bool = Field(default=False)
 
-    # --- TELEMETRY [app.hud.so] ---
+    # --- TELEMETRY [hud.so] ---
     # Responses
     content: str | None = Field(default=None)
     reasoning: str | None = Field(default=None)