@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/tests/test_adversarial.py

@@ -0,0 +1,351 @@
+"""Adversarial test suite — proves the fixes for the bugs caught during
+the 'inverse audit' pass:
+
+  C1. Command injection via task_id in spawn_worker (CRITICAL)
+  H1. SQLiteStore breaks when used from multiple threads (HIGH)
+  H2. .done.json + brief.json non-atomic writes (HIGH)
+  H4. Empty mission intent accepted silently (HIGH)
+  M1. Webhook replay window absent (MEDIUM)
+
+Each test FIRST proves the bug existed in the spirit of the failure and
+THEN proves the fix holds.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import unittest
+from pathlib import Path
+from unittest import mock
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine import worker as W            # noqa: E402
+from omega_engine.done_signal import (          # noqa: E402
+    DoneSignal, done_path, read_done, write_done,
+)
+from omega_engine.store import SQLiteStore      # noqa: E402
+from omega_engine.events import Event, EventType  # noqa: E402
+from omega_engine import webhooks as WH         # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# C1 — Command injection in spawn_worker(task_id=...)
+# ---------------------------------------------------------------------------
+
+
+class TestTaskIdInjectionGuard(unittest.TestCase):
+    def test_validate_accepts_normal_ids(self):
+        for ok in ("t-1", "t_abc.42", "task-2026-05-23-7f3a", "x" * 128):
+            self.assertEqual(W._validate_task_id(ok), ok)
+
+    def test_validate_rejects_semicolon_injection(self):
+        with self.assertRaises(ValueError):
+            W._validate_task_id("t; touch /tmp/PWNED")
+
+    def test_validate_rejects_command_substitution(self):
+        with self.assertRaises(ValueError):
+            W._validate_task_id("t$(rm -rf /)")
+
+    def test_validate_rejects_pipe(self):
+        with self.assertRaises(ValueError):
+            W._validate_task_id("t|rm -rf /")
+
+    def test_validate_rejects_backtick(self):
+        with self.assertRaises(ValueError):
+            W._validate_task_id("t`whoami`")
+
+    def test_validate_rejects_space(self):
+        with self.assertRaises(ValueError):
+            W._validate_task_id("t and more")
+
+    def test_validate_rejects_path_traversal(self):
+        with self.assertRaises(ValueError):
+            W._validate_task_id("../../etc/passwd")
+
+    def test_validate_rejects_empty(self):
+        with self.assertRaises(ValueError):
+            W._validate_task_id("")
+
+    def test_validate_rejects_too_long(self):
+        with self.assertRaises(ValueError):
+            W._validate_task_id("x" * 129)
+
+    def test_spawn_refuses_injection(self):
+        """The real attack vector — spawn_worker must reject before tmux."""
+        with tempfile.TemporaryDirectory() as tmp:
+            brief = W.WorkerBrief(
+                task_id="t; touch /tmp/SHOULD_NEVER_HAPPEN",
+                role="worker", intent="x",
+            )
+            with self.assertRaises(ValueError):
+                W.spawn_worker(brief, home=Path(tmp))
+
+    def test_write_brief_refuses_injection(self):
+        """write_brief is the second line of defence (defence-in-depth)."""
+        with tempfile.TemporaryDirectory() as tmp:
+            # Construct via __init__ (no validator on the dataclass itself)
+            brief = W.WorkerBrief(
+                task_id="t$(id)", role="worker", intent="x",
+            )
+            with self.assertRaises(ValueError):
+                W.write_brief(Path(tmp), brief)
+
+
+# ---------------------------------------------------------------------------
+# H1 — SQLiteStore concurrent access
+# ---------------------------------------------------------------------------
+
+
+class TestStoreThreadSafety(unittest.TestCase):
+    def test_5_threads_append_without_error(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            s = SQLiteStore(str(Path(tmp) / "concurrent.db"))
+            errors: list[str] = []
+
+            def worker(n: int) -> None:
+                try:
+                    for i in range(10):
+                        s.append(Event(
+                            id=f"e-{n}-{i}-{time.time_ns()}",
+                            task_id=f"t-{n}",
+                            type=EventType.HEARTBEAT,
+                            ts=time.time(),
+                            payload={"n": n, "i": i},
+                        ))
+                except Exception as exc:  # noqa: BLE001
+                    errors.append(f"{n}: {type(exc).__name__}: {exc}")
+
+            threads = [threading.Thread(target=worker, args=(n,))
+                       for n in range(5)]
+            for t in threads:
+                t.start()
+            for t in threads:
+                t.join()
+            self.assertEqual(errors, [], f"unexpected errors: {errors}")
+            # 5 threads × 10 events each = 50 events
+            count = sum(1 for _ in s.all_events())
+            self.assertEqual(count, 50)
+            s.close()
+
+    def test_close_is_safe_to_call_twice(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            s = SQLiteStore(str(Path(tmp) / "db.db"))
+            s.close()
+            # Second close MUST not raise — best-effort.
+            s.close()
+
+    def test_reads_under_concurrent_writes(self):
+        """Reader threads must not see a malformed or torn row."""
+        with tempfile.TemporaryDirectory() as tmp:
+            s = SQLiteStore(str(Path(tmp) / "readwrite.db"))
+            stop = threading.Event()
+
+            def writer():
+                i = 0
+                while not stop.is_set():
+                    try:
+                        s.append(Event(
+                            id=f"w-{i}-{time.time_ns()}",
+                            task_id="t-shared",
+                            type=EventType.HEARTBEAT,
+                            ts=time.time(), payload={"i": i},
+                        ))
+                    except Exception:  # noqa: BLE001
+                        pass
+                    i += 1
+
+            errors: list[str] = []
+
+            def reader():
+                try:
+                    for _ in range(20):
+                        s.events_for("t-shared")
+                except Exception as exc:  # noqa: BLE001
+                    errors.append(f"{type(exc).__name__}: {exc}")
+
+            wt = threading.Thread(target=writer)
+            rts = [threading.Thread(target=reader) for _ in range(3)]
+            wt.start()
+            for rt in rts:
+                rt.start()
+            for rt in rts:
+                rt.join()
+            stop.set()
+            wt.join()
+            self.assertEqual(errors, [])
+            s.close()
+
+
+# ---------------------------------------------------------------------------
+# H2 — Atomic writes for .done.json + brief.json
+# ---------------------------------------------------------------------------
+
+
+class TestAtomicWrites(unittest.TestCase):
+    def test_done_json_writes_atomically(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            sig = DoneSignal(status="done_clean", summary="ok",
+                             files_changed=["a.py"])
+            p = write_done(Path(tmp), "t-atom", sig)
+            # The temp file used during the write must not linger.
+            self.assertFalse(p.with_suffix(p.suffix + ".tmp").exists())
+            loaded = read_done(Path(tmp), "t-atom")
+            self.assertEqual(loaded.status, "done_clean")
+
+    def test_brief_json_writes_atomically(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            brief = W.WorkerBrief(task_id="t-atom", role="worker", intent="x")
+            p = W.write_brief(Path(tmp), brief)
+            self.assertFalse(p.with_suffix(p.suffix + ".tmp").exists())
+            self.assertEqual(
+                W.read_brief(Path(tmp), "t-atom").task_id, "t-atom"
+            )
+
+    def test_done_json_round_trip_no_torn_read_under_overwrite(self):
+        """Repeatedly overwrite while a parallel reader polls. With the
+        atomic write, the reader either sees the old JSON or the new JSON
+        — never a half-blob that would raise JSONDecodeError."""
+        with tempfile.TemporaryDirectory() as tmp:
+            sig1 = DoneSignal(status="done_clean", summary="v1")
+            write_done(Path(tmp), "t-loop", sig1)
+            errors: list[str] = []
+            stop = threading.Event()
+
+            def writer():
+                for i in range(50):
+                    write_done(Path(tmp), "t-loop",
+                               DoneSignal(status="done_clean",
+                                          summary=f"v{i}"))
+
+            def reader():
+                while not stop.is_set():
+                    try:
+                        read_done(Path(tmp), "t-loop")
+                    except Exception as exc:  # noqa: BLE001
+                        errors.append(f"{type(exc).__name__}: {exc}")
+
+            rts = [threading.Thread(target=reader) for _ in range(3)]
+            for rt in rts:
+                rt.start()
+            wt = threading.Thread(target=writer)
+            wt.start()
+            wt.join()
+            stop.set()
+            for rt in rts:
+                rt.join()
+            self.assertEqual(errors, [], f"torn-read errors: {errors[:3]}")
+
+
+# ---------------------------------------------------------------------------
+# H4 — Empty intent rejected at CLI level
+# ---------------------------------------------------------------------------
+
+
+class TestEmptyIntentRejected(unittest.TestCase):
+    def test_cli_run_empty_intent_returns_nonzero(self):
+        # Invoke the CLI through subprocess so we exercise argparse + cmd_run
+        # in a real shell — no MockProvider gymnastics.
+        repo = Path(__file__).resolve().parents[1]
+        env = {**os.environ, "OMEGA_HOME": "/tmp/omega-empty-test"}
+        Path("/tmp/omega-empty-test").mkdir(exist_ok=True)
+        proc = subprocess.run(
+            [sys.executable, "-m", "omega_engine.cli", "run", ""],
+            cwd=str(repo), env=env, capture_output=True, text=True,
+            timeout=20,
+        )
+        self.assertNotEqual(proc.returncode, 0,
+            f"empty intent should be rejected: {proc.stdout!r} {proc.stderr!r}")
+        self.assertIn("empty", (proc.stdout + proc.stderr).lower())
+
+    def test_cli_run_whitespace_intent_returns_nonzero(self):
+        repo = Path(__file__).resolve().parents[1]
+        env = {**os.environ, "OMEGA_HOME": "/tmp/omega-empty-test"}
+        Path("/tmp/omega-empty-test").mkdir(exist_ok=True)
+        proc = subprocess.run(
+            [sys.executable, "-m", "omega_engine.cli", "run", "   "],
+            cwd=str(repo), env=env, capture_output=True, text=True,
+            timeout=20,
+        )
+        self.assertNotEqual(proc.returncode, 0)
+
+
+# ---------------------------------------------------------------------------
+# M1 — Webhook replay protection
+# ---------------------------------------------------------------------------
+
+
+class TestWebhookReplayProtection(unittest.TestCase):
+    def setUp(self):
+        self.secret = "test-secret-deadbeef"
+        self.body = b'{"event":"push","ref":"main"}'
+        self.sig = WH.generate_test_signature(
+            "generic", self.body, self.secret,
+        )
+
+    def test_no_timestamp_still_accepts_valid_sig_backwards_compat(self):
+        """v0.5 contract: HMAC alone is enough."""
+        ok, reason = WH.verify_signature(
+            "generic", self.body, self.sig, self.secret,
+        )
+        self.assertTrue(ok, reason)
+
+    def test_fresh_timestamp_within_window_passes(self):
+        ts = str(int(time.time()))
+        ok, reason = WH.verify_signature(
+            "generic", self.body, self.sig, self.secret,
+            timestamp_header_value=ts,
+        )
+        self.assertTrue(ok, reason)
+
+    def test_old_timestamp_rejected_replay(self):
+        old_ts = str(int(time.time() - 600))  # 10 min ago
+        ok, reason = WH.verify_signature(
+            "generic", self.body, self.sig, self.secret,
+            timestamp_header_value=old_ts,
+        )
+        self.assertFalse(ok)
+        self.assertIn("replay window", reason)
+
+    def test_future_timestamp_rejected(self):
+        future_ts = str(int(time.time() + 600))
+        ok, reason = WH.verify_signature(
+            "generic", self.body, self.sig, self.secret,
+            timestamp_header_value=future_ts,
+        )
+        self.assertFalse(ok)
+        self.assertIn("replay window", reason)
+
+    def test_garbage_timestamp_rejected(self):
+        ok, reason = WH.verify_signature(
+            "generic", self.body, self.sig, self.secret,
+            timestamp_header_value="not-a-number",
+        )
+        self.assertFalse(ok)
+        self.assertIn("numeric", reason)
+
+    def test_configurable_window(self):
+        old_ts = str(int(time.time() - 60))  # 60s ago
+        # Default 300s window → ok
+        ok, _ = WH.verify_signature(
+            "generic", self.body, self.sig, self.secret,
+            timestamp_header_value=old_ts,
+        )
+        self.assertTrue(ok)
+        # Tighter 30s window → rejected
+        ok, reason = WH.verify_signature(
+            "generic", self.body, self.sig, self.secret,
+            timestamp_header_value=old_ts, replay_window_s=30,
+        )
+        self.assertFalse(ok)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/omega/Agentik_Engine/tests/test_agents_envelope.py

@@ -0,0 +1,274 @@
+"""Tests for the AISB agent suite plumbing.
+
+Three things to exercise:
+
+  1. ``omega_engine.prompts.load_agent_prompt`` reads the right file, strips
+     YAML frontmatter, and appends LMC + shared protocols when present.
+  2. ``omega_engine.envelope.build_envelope`` produces a ``{system, user}``
+     pair: the system holds the agent prompt + the right orchestration
+     contract; the user holds the verbatim intent + structured context.
+  3. ``omega_engine.done_signal`` round-trips a worker's completion JSON,
+     rejects invalid statuses, and lets the verifier attach an audit.
+"""
+from __future__ import annotations
+
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine.done_signal import (  # noqa: E402
+    DoneSignal,
+    DoneSignalError,
+    attach_audit_to_done,
+    read_done,
+    write_done,
+)
+from omega_engine.envelope import (  # noqa: E402
+    DISPATCHER_ROLES,
+    EXECUTOR_ROLES,
+    EnvelopeContext,
+    VERIFIER_ROLES,
+    build_envelope,
+)
+from omega_engine.prompts import (  # noqa: E402
+    clear_cache,
+    find_agent_file,
+    list_available_agents,
+    load_agent_prompt,
+)
+
+
+def _seed_aisb(home: Path, role: str, body: str, *,
+               with_lmc: bool = False) -> None:
+    suite = home / "Agentik_SSOT" / "agents" / "aisb"
+    suite.mkdir(parents=True, exist_ok=True)
+    (suite / f"{role}.md").write_text(body)
+    if with_lmc:
+        (suite / "lmc-protocol.md").write_text(
+            "## LMC PROTOCOL\n\nLead → Manager → Checker."
+        )
+
+
+class TestPrompts(unittest.TestCase):
+    def setUp(self):
+        clear_cache()
+
+    def test_load_returns_none_when_no_file(self):
+        with tempfile.TemporaryDirectory() as td:
+            self.assertIsNone(load_agent_prompt(td, "oracle"))
+
+    def test_load_strips_yaml_frontmatter(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            _seed_aisb(home, "oracle",
+                       "---\nname: oracle\n---\n# ORACLE\n\nI orchestrate.")
+            text = load_agent_prompt(home, "oracle")
+            self.assertIsNotNone(text)
+            self.assertNotIn("---", text)
+            self.assertIn("# ORACLE", text)
+
+    def test_load_appends_lmc(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            _seed_aisb(home, "architect", "# ARCHITECT", with_lmc=True)
+            text = load_agent_prompt(home, "architect")
+            self.assertIn("# ARCHITECT", text)
+            self.assertIn("LMC PROTOCOL", text)
+
+    def test_find_file_aisb_takes_priority(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            _seed_aisb(home, "oracle", "# AISB-ORACLE")
+            other = home / "Agentik_SSOT" / "agents" / "custom"
+            other.mkdir(parents=True)
+            (other / "oracle.md").write_text("# CUSTOM-ORACLE")
+            path = find_agent_file(home, "oracle")
+            self.assertIn("aisb", str(path))
+
+    def test_list_available_agents(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            for r in ("oracle", "architect", "keymaker"):
+                _seed_aisb(home, r, f"# {r.upper()}")
+            # Also a non-role-looking file that should be excluded.
+            (home / "Agentik_SSOT" / "agents" / "aisb" / "CLAUDE.md").write_text("x")
+            (home / "Agentik_SSOT" / "agents" / "aisb" / "checker-oracle.md").write_text("x")
+            agents = list_available_agents(home)
+            self.assertIn("aisb", agents)
+            self.assertIn("oracle", agents["aisb"])
+            self.assertIn("architect", agents["aisb"])
+            self.assertNotIn("CLAUDE", agents["aisb"])
+            self.assertNotIn("checker-oracle", agents["aisb"])
+
+
+class TestEnvelope(unittest.TestCase):
+    def setUp(self):
+        clear_cache()
+
+    def test_envelope_loads_agent_and_dispatcher_contract(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            _seed_aisb(home, "oracle", "# ORACLE — I orchestrate.")
+            ctx = EnvelopeContext(
+                role="oracle",
+                intent="Fix the login bug",
+                task_id="t-1",
+                mission_id="m-1",
+            )
+            env = build_envelope(home, ctx)
+            self.assertIn("ORACLE", env["system"])
+            self.assertIn("ORCHESTRATION CONTRACT (dispatcher)", env["system"])
+            self.assertIn("Fix the login bug", env["user"])
+
+    def test_envelope_worker_gets_done_json_contract(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            _seed_aisb(home, "worker", "# WORKER")
+            ctx = EnvelopeContext(
+                role="worker", intent="Implement X",
+                done_json_path="/tmp/foo/.done.json",
+                verify_cmd="pytest tests/test_foo.py",
+            )
+            env = build_envelope(home, ctx)
+            self.assertIn("ORCHESTRATION CONTRACT (executor / worker)", env["system"])
+            self.assertIn("/tmp/foo/.done.json", env["system"])
+            self.assertIn("Implement X", env["user"])
+            self.assertIn("pytest tests/test_foo.py", env["user"])
+
+    def test_envelope_verifier_gets_verifier_contract(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            _seed_aisb(home, "seraph", "# SERAPH")
+            ctx = EnvelopeContext(role="seraph", intent="Verify X")
+            env = build_envelope(home, ctx)
+            self.assertIn("ORCHESTRATION CONTRACT (verifier)", env["system"])
+
+    def test_envelope_includes_parent_context(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            _seed_aisb(home, "worker", "# WORKER")
+            ctx = EnvelopeContext(
+                role="worker", intent="Subtask 1",
+                parent_role="oracle",
+                parent_intent="Fix the cart bug",
+                plan_so_far=[{"role": "worker", "spec": {"task": "1"}}],
+            )
+            env = build_envelope(home, ctx)
+            self.assertIn("Fix the cart bug", env["user"])
+            self.assertIn("Plan so far", env["user"])
+
+    def test_role_constants_cover_aisb_agents(self):
+        # All canonical AISB roles must fit in exactly one bucket.
+        for r in ("aisb", "oracle", "manager", "architect", "keymaker", "morpheus"):
+            self.assertIn(r, DISPATCHER_ROLES)
+        for r in ("worker", "construct", "link"):
+            self.assertIn(r, EXECUTOR_ROLES)
+        for r in ("seraph", "audit", "verifier"):
+            self.assertIn(r, VERIFIER_ROLES)
+
+    def test_envelope_falls_back_when_no_agent_file(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)  # no agent files seeded
+            ctx = EnvelopeContext(role="oracle", intent="X")
+            env = build_envelope(home, ctx)
+            # Generic identity line is the floor; contract is still appended.
+            self.assertIn("ORACLE", env["system"].upper())
+            self.assertIn("ORCHESTRATION CONTRACT", env["system"])
+
+
+class TestDoneSignal(unittest.TestCase):
+    def test_round_trip(self):
+        with tempfile.TemporaryDirectory() as td:
+            sig = DoneSignal(
+                status="done_clean",
+                summary="implemented X",
+                files_changed=["a.py", "b.py"],
+                artifacts={"key": "value"},
+            )
+            path = write_done(td, "t-42", sig)
+            self.assertTrue(path.exists())
+            got = read_done(td, "t-42")
+            self.assertEqual(got.status, "done_clean")
+            self.assertEqual(got.files_changed, ["a.py", "b.py"])
+            self.assertEqual(got.artifacts["key"], "value")
+
+    def test_rejects_invalid_status_on_write(self):
+        with tempfile.TemporaryDirectory() as td:
+            sig = DoneSignal(status="all_good")
+            with self.assertRaises(DoneSignalError):
+                write_done(td, "t-1", sig)
+
+    def test_rejects_invalid_status_on_read(self):
+        with tempfile.TemporaryDirectory() as td:
+            from omega_engine.done_signal import session_dir
+            d = session_dir(td, "t-9")
+            (d / ".done.json").write_text(json.dumps({"status": "BAD"}))
+            with self.assertRaises(DoneSignalError):
+                read_done(td, "t-9")
+
+    def test_attach_audit_preserves_existing_fields(self):
+        with tempfile.TemporaryDirectory() as td:
+            sig = DoneSignal(status="pending", summary="halfway",
+                             files_changed=["x.py"])
+            write_done(td, "t-7", sig)
+            attach_audit_to_done(td, "t-7", {"verified": True, "score": 95})
+            got = read_done(td, "t-7")
+            self.assertEqual(got.status, "pending")  # unchanged
+            self.assertEqual(got.files_changed, ["x.py"])
+            self.assertEqual(got.audit["score"], 95)
+            self.assertTrue(got.audit["verified"])
+
+    def test_read_returns_none_when_missing(self):
+        with tempfile.TemporaryDirectory() as td:
+            self.assertIsNone(read_done(td, "t-missing"))
+
+    def test_file_mode_is_600(self):
+        with tempfile.TemporaryDirectory() as td:
+            path = write_done(td, "t-mode", DoneSignal(status="failed"))
+            self.assertEqual(path.stat().st_mode & 0o777, 0o600)
+
+
+class TestProjectVault(unittest.TestCase):
+    def test_project_vault_isolation(self):
+        from omega_engine.vault import (
+            list_project_vaults, vault_read, vault_write,
+        )
+        import shutil as _sh
+
+        if not (_sh.which("age") and _sh.which("age-keygen")):
+            # Plain mode is the test we can run universally.
+            pass
+
+        with tempfile.TemporaryDirectory() as td:
+            # Write a secret in the global vault and one in project "alpha".
+            vault_write(td, "GLOBAL_X", "global-value")
+            vault_write(td, "ALPHA_X", "alpha-value", project="alpha")
+            vault_write(td, "BETA_X", "beta-value", project="beta")
+
+            # Project vaults don't see each other or the global one.
+            self.assertEqual(vault_read(td, "ALPHA_X", project="alpha"),
+                             "alpha-value")
+            self.assertIsNone(vault_read(td, "ALPHA_X"))  # not in global
+            self.assertIsNone(vault_read(td, "ALPHA_X", project="beta"))
+            self.assertEqual(vault_read(td, "GLOBAL_X"), "global-value")
+
+            vaults = list_project_vaults(td)
+            slugs = {v["project"] for v in vaults}
+            self.assertEqual(slugs, {"alpha", "beta"})
+
+    def test_project_vault_rejects_traversal(self):
+        from omega_engine.vault import vault_write
+        with tempfile.TemporaryDirectory() as td:
+            for bad in ("../escape", "a/b", "..", ".hidden"):
+                with self.assertRaises(ValueError):
+                    vault_write(td, "X", "v", project=bad)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)