memgres 0.5.0__tar.gz → 0.5.2__tar.gz

{memgres-0.5.0 → memgres-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgres
-Version: 0.5.0
+Version: 0.5.2
 Summary: Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable.
 Author: mozgsml
 License-Expression: MIT

{memgres-0.5.0 → memgres-0.5.2}/memgres/_version.py

@@ -8,4 +8,4 @@ here at release; nowhere else carries the number.
 PEP 440: a ``.devN`` suffix marks an unreleased build ahead of the last tag.
 """
 
-__version__ = "0.5.0"
+__version__ = "0.5.2"

memgres-0.5.2/memgres/healthcheck.py

@@ -0,0 +1,88 @@
+"""Container liveness probe that knows which role the container is running.
+
+One image, two entrypoints: ``memgres-server`` (REST, ``MEMGRES_HTTP_PORT``,
+answers ``/healthz``) and ``memgres-mcp`` (MCP, ``MEMGRES_MCP_PORT``, answers
+``/mcp`` and has no ``/healthz``). The old Dockerfile HEALTHCHECK probed a
+hardcoded ``localhost:8080/healthz``, so an MCP container was reported unhealthy
+forever — it never listens on 8080. A permanently-red healthcheck is worse than
+none: it masks real failures and blocks anything waiting on ``service_healthy``.
+
+The role comes from PID 1's argv, not from an env convention, so it stays right
+even when a deployment sets MCP variables on a REST container or vice versa.
+
+Two details that make the probe honest rather than merely green:
+
+* **127.0.0.1, not ``localhost``** — a server bound to ``0.0.0.0`` listens on
+  IPv4 only, while ``localhost`` may resolve to ``::1`` first and be refused.
+* **For MCP, any HTTP answer means healthy.** Streamable HTTP rejects a bare GET
+  with 400; that response still proves the port is bound and the app is serving.
+  Only a refused connection or a timeout is a real failure.
+"""
+
+import os
+import sys
+import urllib.error
+import urllib.request
+
+#: MEMGRES_MCP_TRANSPORT values that make the MCP server listen on a socket.
+#: Anything else (i.e. stdio) is spoken over the process's own pipes.
+HTTP_TRANSPORTS = ("http", "streamable-http", "streamable_http")
+
+_TIMEOUT = 3
+
+
+def _pid1_argv() -> list:
+    """PID 1's argv — the command the container was actually started with."""
+    try:
+        with open("/proc/1/cmdline", "rb") as fh:
+            return [a for a in fh.read().decode("utf-8", "replace").split("\0") if a]
+    except OSError:
+        return []                      # not Linux / no procfs — fall back to REST
+
+
+def role(argv=None) -> str:
+    """``"mcp"`` or ``"rest"``. REST is the default, matching the image's CMD."""
+    argv = _pid1_argv() if argv is None else argv
+    for arg in argv:
+        if "memgres-mcp" in arg or "mcp_server" in arg:
+            return "mcp"
+    return "rest"
+
+
+def _answers(url: str) -> bool:
+    """True if something at `url` speaks HTTP — any status, including errors."""
+    try:
+        urllib.request.urlopen(url, timeout=_TIMEOUT)
+        return True
+    except urllib.error.HTTPError:
+        return True                    # bound and serving (MCP GET → 400)
+    except (urllib.error.URLError, OSError):
+        return False                   # refused, unresolved, timed out
+
+
+def _status_ok(url: str) -> bool:
+    """True only on a 200 — used where a real health endpoint exists."""
+    try:
+        return urllib.request.urlopen(url, timeout=_TIMEOUT).status == 200
+    except (urllib.error.HTTPError, urllib.error.URLError, OSError):
+        return False
+
+
+def check() -> int:
+    """Exit code for the probe: 0 healthy, 1 unhealthy."""
+    if role() == "mcp":
+        transport = os.environ.get("MEMGRES_MCP_TRANSPORT", "stdio").lower()
+        if transport not in HTTP_TRANSPORTS:
+            return 0                   # stdio: no socket; docker already sees the process
+        port = os.environ.get("MEMGRES_MCP_PORT", "8765")
+        return 0 if _answers(f"http://127.0.0.1:{port}/mcp") else 1
+    port = os.environ.get("MEMGRES_HTTP_PORT", "8080")
+    return 0 if _status_ok(f"http://127.0.0.1:{port}/healthz") else 1
+
+
+def main():  # pragma: no cover - entrypoint
+    sys.exit(check())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

{memgres-0.5.0 → memgres-0.5.2}/memgres/mcp_server.py

@@ -426,9 +426,18 @@ def main():  # pragma: no cover - entrypoint
     server = build_server()
     transport = os.environ.get("MEMGRES_MCP_TRANSPORT", "stdio").lower()
     if transport in ("http", "streamable-http", "streamable_http"):
-        server.settings.host = os.environ.get("MEMGRES_MCP_HOST", "0.0.0.0")
-        server.settings.port = int(os.environ.get("MEMGRES_MCP_PORT", "8765"))
-        server.run(transport="streamable-http")
+        host = os.environ.get("MEMGRES_MCP_HOST", "0.0.0.0")
+        port = int(os.environ.get("MEMGRES_MCP_PORT", "8765"))
+        # mcp SDK 1.x (FastMCP) reads host/port from `settings`; 2.x (MCPServer)
+        # dropped those fields and takes them as run() kwargs (forwarded to
+        # run_streamable_http_async). Pick the path the installed SDK supports.
+        fields = getattr(type(server.settings), "model_fields", {})
+        if "host" in fields:
+            server.settings.host = host
+            server.settings.port = port
+            server.run(transport="streamable-http")
+        else:
+            server.run(transport="streamable-http", host=host, port=port)
     else:
         server.run()
 

{memgres-0.5.0 → memgres-0.5.2}/memgres.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgres
-Version: 0.5.0
+Version: 0.5.2
 Summary: Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable.
 Author: mozgsml
 License-Expression: MIT

{memgres-0.5.0 → memgres-0.5.2}/memgres.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ memgres/config.py
 memgres/diffing.py
 memgres/embed_worker.py
 memgres/embeddings.py
+memgres/healthcheck.py
 memgres/identity.py
 memgres/indexing.py
 memgres/info.py
@@ -46,10 +47,12 @@ tests/test_config.py
 tests/test_diffing.py
 tests/test_embed_worker.py
 tests/test_embeddings.py
+tests/test_healthcheck.py
 tests/test_identity_integration.py
 tests/test_lexical_match.py
 tests/test_limits.py
 tests/test_list.py
+tests/test_mcp_http_transport.py
 tests/test_mcp_instructions.py
 tests/test_mcp_recall_schema.py
 tests/test_migration_upgrade.py

{memgres-0.5.0 → memgres-0.5.2}/memgres.egg-info/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 memgres-grant-superadmin = memgres.admin_cli:main
+memgres-healthcheck = memgres.healthcheck:main
 memgres-mcp = memgres.mcp_server:main
 memgres-reembed = memgres.reembed:main
 memgres-server = memgres.server:main

{memgres-0.5.0 → memgres-0.5.2}/pyproject.toml

@@ -41,6 +41,7 @@ memgres-mcp = "memgres.mcp_server:main"
 memgres-worker = "memgres.worker:main"
 memgres-reembed = "memgres.reembed:main"
 memgres-grant-superadmin = "memgres.admin_cli:main"
+memgres-healthcheck = "memgres.healthcheck:main"
 
 [build-system]
 requires = ["setuptools>=68"]

memgres-0.5.2/tests/test_healthcheck.py

@@ -0,0 +1,146 @@
+"""The container probe must match the role the container is running.
+
+Regression guard: the Dockerfile HEALTHCHECK used to hit a fixed
+``localhost:8080/healthz``, which the MCP entrypoint never serves — every MCP
+container sat "unhealthy" forever while serving fine. The last test here is that
+exact scenario.
+
+No database needed: these exercise role detection and the probes against a
+throwaway HTTP server.
+"""
+
+import socket
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import pytest
+
+from memgres import healthcheck as hc
+
+
+def _serve(status: int):
+    """Run a one-route HTTP server on a free port; yields its port."""
+    class Handler(BaseHTTPRequestHandler):
+        def do_GET(self):                       # noqa: N802 - stdlib naming
+            self.send_response(status)
+            self.end_headers()
+            self.wfile.write(b"{}")
+
+        def log_message(self, *a):              # keep pytest output clean
+            pass
+
+    srv = HTTPServer(("127.0.0.1", 0), Handler)
+    threading.Thread(target=srv.serve_forever, daemon=True).start()
+    return srv
+
+
+def _free_port() -> int:
+    s = socket.socket()
+    s.bind(("127.0.0.1", 0))
+    port = s.getsockname()[1]
+    s.close()
+    return port
+
+
+# ─── role detection ────────────────────────────────────────────────────────────
+
+@pytest.mark.parametrize("argv", [
+    ["/usr/local/bin/memgres-mcp"],
+    ["python", "-m", "memgres.mcp_server"],
+])
+def test_role_detects_mcp(argv):
+    assert hc.role(argv) == "mcp"
+
+
+@pytest.mark.parametrize("argv", [
+    ["/usr/local/bin/memgres-server"],
+    [],                                          # no procfs → default
+])
+def test_role_defaults_to_rest(argv):
+    assert hc.role(argv) == "rest"
+
+
+# ─── probes ────────────────────────────────────────────────────────────────────
+
+def test_answers_accepts_any_http_status():
+    """A bare GET to Streamable HTTP returns 400 — still proof it is serving."""
+    srv = _serve(400)
+    try:
+        assert hc._answers(f"http://127.0.0.1:{srv.server_port}/mcp") is True
+    finally:
+        srv.shutdown()
+
+
+def test_answers_false_when_nothing_listens():
+    assert hc._answers(f"http://127.0.0.1:{_free_port()}/mcp") is False
+
+
+def test_status_ok_requires_200():
+    srv = _serve(500)
+    try:
+        assert hc._status_ok(f"http://127.0.0.1:{srv.server_port}/healthz") is False
+    finally:
+        srv.shutdown()
+
+
+# ─── check() per role ──────────────────────────────────────────────────────────
+
+def test_mcp_http_healthy_when_port_answers(monkeypatch):
+    srv = _serve(400)
+    try:
+        monkeypatch.setattr(hc, "role", lambda *a: "mcp")
+        monkeypatch.setenv("MEMGRES_MCP_TRANSPORT", "http")
+        monkeypatch.setenv("MEMGRES_MCP_PORT", str(srv.server_port))
+        assert hc.check() == 0
+    finally:
+        srv.shutdown()
+
+
+def test_mcp_http_unhealthy_when_dead(monkeypatch):
+    monkeypatch.setattr(hc, "role", lambda *a: "mcp")
+    monkeypatch.setenv("MEMGRES_MCP_TRANSPORT", "http")
+    monkeypatch.setenv("MEMGRES_MCP_PORT", str(_free_port()))
+    assert hc.check() == 1
+
+
+def test_mcp_stdio_is_healthy_without_a_socket(monkeypatch):
+    """stdio speaks over pipes; there is no port to probe, so never fail it."""
+    monkeypatch.setattr(hc, "role", lambda *a: "mcp")
+    monkeypatch.delenv("MEMGRES_MCP_TRANSPORT", raising=False)
+    assert hc.check() == 0
+
+
+def test_rest_healthy_on_200(monkeypatch):
+    srv = _serve(200)
+    try:
+        monkeypatch.setattr(hc, "role", lambda *a: "rest")
+        monkeypatch.setenv("MEMGRES_HTTP_PORT", str(srv.server_port))
+        assert hc.check() == 0
+    finally:
+        srv.shutdown()
+
+
+def test_rest_honours_configured_port(monkeypatch):
+    """The old probe hardcoded 8080 and broke on a remapped REST port."""
+    srv = _serve(200)
+    try:
+        monkeypatch.setattr(hc, "role", lambda *a: "rest")
+        monkeypatch.setenv("MEMGRES_HTTP_PORT", str(srv.server_port))
+        assert hc.check() == 0
+        monkeypatch.setenv("MEMGRES_HTTP_PORT", str(_free_port()))
+        assert hc.check() == 1
+    finally:
+        srv.shutdown()
+
+
+def test_regression_mcp_container_without_8080_is_healthy(monkeypatch):
+    """THE BUG: MCP serves on 8765 and nothing listens on 8080 — must be green."""
+    srv = _serve(400)
+    try:
+        monkeypatch.setattr(hc, "role", lambda *a: "mcp")
+        monkeypatch.setenv("MEMGRES_MCP_TRANSPORT", "streamable-http")
+        monkeypatch.setenv("MEMGRES_MCP_PORT", str(srv.server_port))
+        monkeypatch.setenv("MEMGRES_HTTP_PORT", "8080")   # nothing there, as in prod
+        assert hc.check() == 0
+    finally:
+        srv.shutdown()

memgres-0.5.2/tests/test_mcp_http_transport.py

@@ -0,0 +1,86 @@
+"""The http transport must actually bind its port.
+
+Regression guard for the mcp SDK 2.x drift: `main()` used to set
+`server.settings.host`, which 2.x's MCPServer rejects ("Settings object has no
+field host"), so the server crash-looped and never served. This spawns the real
+entrypoint over HTTP and asserts the port answers.
+"""
+
+import os
+import socket
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+import pytest
+
+psycopg = pytest.importorskip("psycopg")
+
+DSN = os.environ.get("MEMGRES_TEST_DSN",
+                     "postgresql://memgres:memgres@localhost:55432/memgres")
+
+
+def _reachable() -> bool:
+    try:
+        psycopg.connect(DSN, connect_timeout=2).close()
+        return True
+    except Exception:
+        return False
+
+
+pytestmark = pytest.mark.skipif(not _reachable(), reason="no test Postgres")
+
+
+def _free_port() -> int:
+    s = socket.socket()
+    s.bind(("127.0.0.1", 0))
+    port = s.getsockname()[1]
+    s.close()
+    return port
+
+
+def test_http_transport_binds_and_answers():
+    port = _free_port()
+    env = {**os.environ,
+           "MEMGRES_DATABASE_URL": DSN,
+           "MEMGRES_KEY_MODE": "single",
+           "MEMGRES_EMBED_PROVIDER": "none",
+           "MEMGRES_MCP_TRANSPORT": "http",
+           "MEMGRES_MCP_HOST": "127.0.0.1",
+           "MEMGRES_MCP_PORT": str(port)}
+    root = str(Path(__file__).resolve().parent.parent)
+    env["PYTHONPATH"] = root + os.pathsep + env.get("PYTHONPATH", "")
+    proc = subprocess.Popen([sys.executable, "-m", "memgres.mcp_server"],
+                            env=env, stdout=subprocess.PIPE,
+                            stderr=subprocess.STDOUT, text=True)
+    url = f"http://127.0.0.1:{port}/mcp"
+    try:
+        deadline = time.time() + 25
+        answered = False
+        while time.time() < deadline:
+            if proc.poll() is not None:
+                out = proc.stdout.read() if proc.stdout else ""
+                pytest.fail(f"server exited early (code {proc.returncode}):\n{out}")
+            try:
+                urllib.request.urlopen(url, timeout=2)
+                answered = True            # 2xx (unlikely for a bare GET)
+                break
+            except urllib.error.HTTPError:
+                answered = True            # bound and speaking HTTP (e.g. 400/406)
+                break
+            except (urllib.error.URLError, ConnectionError, OSError):
+                time.sleep(0.5)            # not up yet — retry
+        assert answered, f"{url} never answered — the transport did not bind"
+    finally:
+        proc.terminate()
+        try:
+            proc.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(pytest.main([__file__, "-v"]))