@marsnme/mcp-gateway 0.1.1

package/scripts/hermes_digest_runner.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+import importlib.util
+import json
+import os
+from pathlib import Path
+
+def load_dream_runner():
+    script_path = Path(__file__).resolve().parent / "dream_runner.py"
+    if not script_path.exists():
+        raise RuntimeError(f"dream runner not found: {script_path}")
+    spec = importlib.util.spec_from_file_location("dream_runner", script_path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot load dream runner module: {script_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+def bridge_legacy_env():
+    if "DREAM_ENABLED" not in os.environ and "HERMES_ENABLED" in os.environ:
+        os.environ["DREAM_ENABLED"] = os.environ["HERMES_ENABLED"]
+    if "DREAM_MODE" not in os.environ:
+        os.environ["DREAM_MODE"] = "pro"
+    if "DREAM_COMPAT_HERMES" not in os.environ:
+        os.environ["DREAM_COMPAT_HERMES"] = "true"
+
+def main() -> int:
+    try:
+        bridge_legacy_env()
+        runner = load_dream_runner()
+        return int(runner.main())
+    except Exception as exc:
+        print(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False))
+        return 1
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/tests/test_dream_runner_modes.py

@@ -0,0 +1,90 @@
+import json
+import os
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+from typing import Optional
+
+
+ROOT = Path(__file__).resolve().parents[3]
+DREAM_RUNNER = ROOT / "soul-memory" / "scripts" / "dream_runner.py"
+HERMES_WRAPPER = ROOT / "soul-memory" / "scripts" / "hermes_digest_runner.py"
+
+
+class DreamRunnerModeTests(unittest.TestCase):
+    def _run_script(
+        self,
+        script: Path,
+        extra_env: dict[str, str],
+        unset_keys: Optional[list[str]] = None,
+    ) -> dict:
+        with tempfile.TemporaryDirectory(prefix="dream-runner-test-") as tmp_home:
+            env = os.environ.copy()
+            env.update(
+                {
+                    "HOME": tmp_home,
+                    "DREAM_ENV_FILE": str(Path(tmp_home) / ".env.none"),
+                    "DREAM_PROFILE_ENV_FILE": str(Path(tmp_home) / ".profile.env.none"),
+                    "DREAM_ENABLED": "false",
+                }
+            )
+            for key in unset_keys or []:
+                env.pop(key, None)
+            env.update(extra_env)
+            result = subprocess.run(
+                ["python3", str(script)],
+                cwd=str(ROOT),
+                capture_output=True,
+                text=True,
+                check=False,
+                env=env,
+            )
+            self.assertEqual(
+                result.returncode,
+                0,
+                msg=f"script failed: {result.stderr.strip()}\nstdout={result.stdout.strip()}",
+            )
+            lines = [line.strip() for line in result.stdout.splitlines() if line.strip()]
+            self.assertTrue(lines, msg="script produced no output")
+            return json.loads(lines[-1])
+
+    def test_default_mode_is_standard_when_unset(self):
+        payload = self._run_script(DREAM_RUNNER, {"DREAM_MODE": ""})
+        self.assertTrue(payload.get("ok"))
+        self.assertTrue(payload.get("skipped"))
+        self.assertEqual(payload.get("mode"), "standard")
+
+    def test_lite_mode_respected(self):
+        payload = self._run_script(DREAM_RUNNER, {"DREAM_MODE": "lite"})
+        self.assertTrue(payload.get("ok"))
+        self.assertTrue(payload.get("skipped"))
+        self.assertEqual(payload.get("mode"), "lite")
+
+    def test_pro_mode_respected(self):
+        payload = self._run_script(DREAM_RUNNER, {"DREAM_MODE": "pro"})
+        self.assertTrue(payload.get("ok"))
+        self.assertTrue(payload.get("skipped"))
+        self.assertEqual(payload.get("mode"), "pro")
+
+    def test_invalid_mode_falls_back_to_standard(self):
+        payload = self._run_script(DREAM_RUNNER, {"DREAM_MODE": "weird-mode"})
+        self.assertTrue(payload.get("ok"))
+        self.assertTrue(payload.get("skipped"))
+        self.assertEqual(payload.get("mode"), "standard")
+
+    def test_legacy_wrapper_bridges_to_dream_and_defaults_to_pro(self):
+        payload = self._run_script(
+            HERMES_WRAPPER,
+            {
+                "HERMES_ENABLED": "false",
+            },
+            unset_keys=["DREAM_ENABLED", "DREAM_MODE"],
+        )
+        self.assertTrue(payload.get("ok"))
+        self.assertTrue(payload.get("skipped"))
+        self.assertEqual(payload.get("mode"), "pro")
+
+
+if __name__ == "__main__":
+    unittest.main()