@agentikos/omega-os 0.2.0 → 0.19.5

package/omega/Agentik_Engine/tests/test_hermes_bootstrap_and_desktop.py

@@ -0,0 +1,358 @@
+"""Tests for v0.19 additions: Hermès bootstrap (self-improvement), tmux
+pro config, Hermes Desktop remote-backend adapter.
+"""
+from __future__ import annotations
+
+import json
+import os
+import socket
+import sys
+import tempfile
+import threading
+import time
+import unittest
+import urllib.error
+import urllib.request
+from pathlib import Path
+from unittest import mock
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine import hermes_bootstrap as HB    # noqa: E402
+from omega_engine import hermes_desktop as HD       # noqa: E402
+from omega_engine import tmux as TX                  # noqa: E402
+from omega_engine.done_signal import DoneSignal, write_done  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Hermès bootstrap — write_brief + observe_outcome + status
+# ---------------------------------------------------------------------------
+
+
+class TestHermesBootstrapBrief(unittest.TestCase):
+    def test_write_brief_creates_skill_md(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            hh = Path(tmp) / ".hermes"
+            res = HB.write_brief(omega_home=home, hermes_home=hh)
+            self.assertTrue(res.written)
+            p = HB.brief_path(hh)
+            self.assertTrue(p.exists())
+            content = p.read_text()
+            # The brief MUST mention the 5-layer architecture
+            self.assertIn("L1 Human", content)
+            self.assertIn("L2 You (Hermès)", content)
+            self.assertIn("L3 AISB", content)
+            self.assertIn("L4 Oracle", content)
+            self.assertIn("L5 Workers", content)
+            # Must reference the no-API-key principle
+            self.assertIn("OAuth", content)
+            self.assertIn("CLAUDE_CODE_OAUTH_TOKEN", content) if False else None
+            # Must mention the engine commands Hermès should call
+            for cmd in ("omega run", "omega genesis", "omega plan",
+                        "omega audit"):
+                self.assertIn(cmd, content)
+
+    def test_write_brief_atomic_no_tmp_leftover(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            hh = Path(tmp) / ".hermes"
+            HB.write_brief(hermes_home=hh)
+            siblings = list(HB.brief_path(hh).parent.glob("*.tmp.*"))
+            self.assertEqual(siblings, [])
+
+    def test_brief_path_default_is_user_hermes(self):
+        self.assertEqual(
+            HB.brief_path(),
+            Path.home() / ".hermes" / "skills" / "omega" / "SKILL.md",
+        )
+
+
+class TestObserveOutcome(unittest.TestCase):
+    def test_observe_appends_jsonl(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            hh = Path(tmp) / ".hermes"
+            # Seed a .done.json so observe has something to read.
+            write_done(home, "t-obs", DoneSignal(
+                status="done_clean", summary="all good",
+                files_changed=["a.py"],
+            ))
+            obs = HB.observe_outcome(
+                "demo", "t-obs",
+                omega_home=home, hermes_home=hh,
+            )
+            self.assertIsNotNone(obs)
+            self.assertEqual(obs.task_id, "t-obs")
+            self.assertEqual(obs.status, "done_clean")
+            # The log file exists and contains one JSON line.
+            log = HB.memory_log_path(hh)
+            self.assertTrue(log.exists())
+            lines = log.read_text().splitlines()
+            self.assertEqual(len(lines), 1)
+            parsed = json.loads(lines[0])
+            self.assertEqual(parsed["task_id"], "t-obs")
+
+    def test_observe_returns_none_when_no_done(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            res = HB.observe_outcome(
+                "demo", "never-existed",
+                omega_home=Path(tmp), hermes_home=Path(tmp) / ".hermes",
+            )
+            self.assertIsNone(res)
+
+    def test_observe_multiple_outcomes_accumulate(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            hh = Path(tmp) / ".hermes"
+            for i in range(3):
+                write_done(home, f"t-{i}", DoneSignal(
+                    status="done_clean", summary=f"task {i}",
+                ))
+                HB.observe_outcome(
+                    "demo", f"t-{i}",
+                    omega_home=home, hermes_home=hh,
+                )
+            lines = HB.memory_log_path(hh).read_text().splitlines()
+            self.assertEqual(len(lines), 3)
+
+
+class TestBootstrapStatus(unittest.TestCase):
+    def test_status_reports_absent_when_no_brief(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            st = HB.status(hermes_home=Path(tmp) / ".hermes")
+            self.assertFalse(st["brief_present"])
+            self.assertEqual(st["brief_size"], 0)
+            self.assertEqual(st["observation_count"], 0)
+            self.assertIsNone(st["last_observed_at"])
+
+    def test_status_reports_present_after_write(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            hh = Path(tmp) / ".hermes"
+            HB.write_brief(hermes_home=hh)
+            st = HB.status(hermes_home=hh)
+            self.assertTrue(st["brief_present"])
+            self.assertGreater(st["brief_size"], 1000)
+
+
+# ---------------------------------------------------------------------------
+# Tmux pro config
+# ---------------------------------------------------------------------------
+
+
+class TestTmuxProConfig(unittest.TestCase):
+    def test_pro_config_includes_paste_fix(self):
+        # The whole reason we ported the live VPS conf — fixes the
+        # large-paste PTY deadlock that hits every Termius user.
+        self.assertIn("assume-paste-time 0", TX._PRO_CONFIG)
+        self.assertIn("buffer-limit", TX._PRO_CONFIG)
+
+    def test_pro_config_includes_kill_forensics(self):
+        # Session-closed + pane-died logged so dead workers leave a trace.
+        self.assertIn("SESSION CLOSED", TX._PRO_CONFIG)
+        self.assertIn("PANE DIED", TX._PRO_CONFIG)
+        self.assertIn("tmux-session-kills.log", TX._PRO_CONFIG)
+
+    def test_pro_config_keeps_prefix_z_picker(self):
+        self.assertIn("bind-key Z display-popup", TX._PRO_CONFIG)
+        self.assertIn("omega tmux menu", TX._PRO_CONFIG)
+
+    def test_write_default_config_minimal_vs_pro_differ(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            m = TX.write_default_config(
+                target=Path(tmp) / "min.conf", profile="minimal",
+            )
+            p = TX.write_default_config(
+                target=Path(tmp) / "pro.conf", profile="pro",
+            )
+            self.assertLess(m.stat().st_size, p.stat().st_size)
+            self.assertNotIn("assume-paste-time 0", m.read_text())
+            self.assertIn("assume-paste-time 0", p.read_text())
+
+    def test_install_into_home_creates_backup(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            fake_home = Path(tmp) / "h"
+            fake_home.mkdir()
+            fake_conf = fake_home / ".tmux.conf"
+            fake_conf.write_text("# existing user config\nbind a kill-pane\n")
+            with mock.patch.object(Path, "home", return_value=fake_home):
+                res = TX.install_into_home_tmux_conf(
+                    profile="pro", backup=True,
+                    omega_home=Path(tmp) / "Omega",
+                )
+            # New conf is the pro template
+            self.assertIn("assume-paste-time 0", fake_conf.read_text())
+            # Backup file exists with the old content
+            self.assertTrue(res["backup_path"])
+            self.assertTrue(Path(res["backup_path"]).exists())
+            self.assertIn(
+                "existing user config",
+                Path(res["backup_path"]).read_text(),
+            )
+
+    def test_install_into_home_no_backup_flag(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            fake_home = Path(tmp) / "h"
+            fake_home.mkdir()
+            (fake_home / ".tmux.conf").write_text("# original\n")
+            with mock.patch.object(Path, "home", return_value=fake_home):
+                res = TX.install_into_home_tmux_conf(
+                    profile="minimal", backup=False,
+                    omega_home=Path(tmp) / "Omega",
+                )
+            self.assertEqual(res["backup_path"], "")
+
+
+# ---------------------------------------------------------------------------
+# Hermes Desktop adapter — token + profile + HTTP server
+# ---------------------------------------------------------------------------
+
+
+class TestHermesDesktopToken(unittest.TestCase):
+    def test_generate_token_creates_mode_0600(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            tok = HD.generate_token(home)
+            self.assertEqual(len(tok), 40)
+            self.assertTrue(set(tok).issubset("0123456789abcdef"))
+            p = HD.token_path(home)
+            mode = oct(p.stat().st_mode)[-3:]
+            self.assertEqual(mode, "600")
+
+    def test_read_token_returns_persisted_value(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            tok = HD.generate_token(home)
+            self.assertEqual(HD.read_token(home), tok)
+
+    def test_read_token_returns_none_when_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            self.assertIsNone(HD.read_token(Path(tmp)))
+
+    def test_build_profile_has_paste_ready_fields(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            prof = HD.build_profile(port=9999, omega_home=Path(tmp))
+            self.assertEqual(prof.base_url, "http://127.0.0.1:9999")
+            self.assertEqual(len(prof.api_key), 40)
+            self.assertIn("OmegaOS", prof.name)
+
+
+class TestHermesDesktopServer(unittest.TestCase):
+    """Spin a real HTTP server on a free port and exercise the routes."""
+
+    def _free_port(self) -> int:
+        with socket.socket() as s:
+            s.bind(("127.0.0.1", 0))
+            return s.getsockname()[1]
+
+    def _start(self, omega_home: Path, port: int, token: str | None = None):
+        srv = HD.serve(
+            host="127.0.0.1", port=port,
+            omega_home=omega_home, token=token, quiet=True,
+        )
+        t = threading.Thread(target=srv.serve_forever, daemon=True)
+        t.start()
+        return srv
+
+    def _get(self, port: int, path: str, *, token: str | None = None):
+        req = urllib.request.Request(f"http://127.0.0.1:{port}{path}")
+        if token:
+            req.add_header("Authorization", f"Bearer {token}")
+        try:
+            with urllib.request.urlopen(req, timeout=5) as resp:
+                return resp.status, json.loads(resp.read())
+        except urllib.error.HTTPError as exc:
+            return exc.code, json.loads(exc.read() or b"{}")
+
+    def test_health_endpoint_open(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            port = self._free_port()
+            srv = self._start(Path(tmp), port)
+            try:
+                # No token required for /api/health
+                code, body = self._get(port, "/api/health")
+                self.assertEqual(code, 200)
+                self.assertEqual(body["status"], "ok")
+            finally:
+                srv.shutdown(); srv.server_close()
+
+    def test_protected_routes_require_token(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            port = self._free_port()
+            srv = self._start(Path(tmp), port, token="tok-secret")
+            try:
+                code, body = self._get(port, "/api/version")
+                self.assertEqual(code, 401)
+                self.assertIn("token", body["error"])
+            finally:
+                srv.shutdown(); srv.server_close()
+
+    def test_version_endpoint_with_valid_token(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            port = self._free_port()
+            srv = self._start(Path(tmp), port, token="tok-good")
+            try:
+                code, body = self._get(port, "/api/version", token="tok-good")
+                self.assertEqual(code, 200)
+                self.assertIn("omega_version", body)
+                self.assertIn("api_routes", body)
+            finally:
+                srv.shutdown(); srv.server_close()
+
+    def test_wrong_token_rejected(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            port = self._free_port()
+            srv = self._start(Path(tmp), port, token="real")
+            try:
+                code, _ = self._get(port, "/api/version", token="fake")
+                self.assertEqual(code, 401)
+            finally:
+                srv.shutdown(); srv.server_close()
+
+    def test_unknown_route_404(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            port = self._free_port()
+            srv = self._start(Path(tmp), port, token="t")
+            try:
+                code, _ = self._get(port, "/api/no-such-thing", token="t")
+                self.assertEqual(code, 404)
+            finally:
+                srv.shutdown(); srv.server_close()
+
+    def test_sessions_list_returns_empty_array(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            port = self._free_port()
+            srv = self._start(Path(tmp), port, token="t")
+            try:
+                code, body = self._get(port, "/api/sessions", token="t")
+                self.assertEqual(code, 200)
+                self.assertEqual(body.get("sessions"), [])
+            finally:
+                srv.shutdown(); srv.server_close()
+
+    def test_skills_endpoint_lists_omega_skills(self):
+        # Use the live repo's SSOT (24 skills) so we get a non-empty list
+        repo_omega = Path(__file__).resolve().parents[3] / "omega"
+        with tempfile.TemporaryDirectory() as tmp:
+            port = self._free_port()
+            srv = self._start(repo_omega, port, token="t")
+            try:
+                code, body = self._get(port, "/api/skills", token="t")
+                self.assertEqual(code, 200)
+                names = {s["name"] for s in body["skills"]
+                         if s.get("source") == "omega-ssot"}
+                self.assertGreaterEqual(len(names), 20)
+            finally:
+                srv.shutdown(); srv.server_close()
+
+
+class TestRefuseUnsafePublic(unittest.TestCase):
+    def test_serve_rejects_0_0_0_0_without_flag(self):
+        with self.assertRaises(RuntimeError) as ctx:
+            HD.serve(host="0.0.0.0", port=65500, token="t")
+        self.assertIn("0.0.0.0", str(ctx.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()