@agentikos/omega-os 0.2.0 → 0.19.5

package/omega/Agentik_Engine/tests/test_install_steps.py

@@ -0,0 +1,359 @@
+"""Integration tests for the manifest-driven install helpers.
+
+`bootstrap/lib/manifest-helpers.py` is a small Python tool the shell calls
+to project the manifest's `providers:` / `autonomous_agents:` / `options.rag`
+into the SSOT. These tests run it as a subprocess against fixture manifests
+and assert the artefacts land in the right place with the right content.
+
+Also a smoke check that the four new install steps (35-providers,
+55-autonomous, 57-rag, 60-services) are present in the wired installer.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+HELPER = REPO_ROOT / "bootstrap" / "lib" / "manifest-helpers.py"
+TEMPLATES = REPO_ROOT / "bootstrap" / "templates" / "autonomous"
+INSTALL_SH = REPO_ROOT / "install.sh"
+STEPS_SH = REPO_ROOT / "bootstrap" / "lib" / "steps.sh"
+
+
+def _run(*argv: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [sys.executable, str(HELPER), *argv],
+        check=False, capture_output=True, text=True, timeout=60,
+    )
+
+
+class TestProviders(unittest.TestCase):
+    def test_providers_writes_router_yaml(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            home.mkdir()
+            manifest = Path(td) / "manifest.yaml"
+            manifest.write_text(yaml.safe_dump({
+                "providers": [
+                    {"id": "claude", "roles": ["oracle", "worker"]},
+                    {"id": "glm", "roles": ["aisb"]},
+                ],
+            }))
+            proc = _run("providers", str(manifest), str(home))
+            self.assertEqual(proc.returncode, 0, msg=proc.stderr)
+
+            target = home / "Agentik_SSOT" / "providers" / "router.yaml"
+            self.assertTrue(target.exists())
+            data = yaml.safe_load(target.read_text())
+            ids = [p["id"] for p in data["providers"]]
+            self.assertEqual(ids, ["claude", "glm"])
+            # secret_ref defaulted
+            claude = next(p for p in data["providers"] if p["id"] == "claude")
+            self.assertEqual(claude["secret_ref"], "CLAUDE_API_KEY")
+            self.assertIn("oracle", claude["roles"])
+
+    def test_providers_no_block_is_noop(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            home.mkdir()
+            manifest = Path(td) / "manifest.yaml"
+            manifest.write_text("profile: vps\n")
+            proc = _run("providers", str(manifest), str(home))
+            self.assertEqual(proc.returncode, 0)
+            self.assertIn("no `providers:`", proc.stdout)
+            self.assertFalse(
+                (home / "Agentik_SSOT" / "providers" / "router.yaml").exists()
+            )
+
+
+class TestAutonomous(unittest.TestCase):
+    def test_copies_template_for_listed_agent(self):
+        with tempfile.TemporaryDirectory() as td:
+            target = Path(td) / "autonomous"
+            manifest = Path(td) / "manifest.yaml"
+            manifest.write_text(yaml.safe_dump({
+                "autonomous_agents": ["support-agent"],
+            }))
+            proc = _run("autonomous", str(manifest), str(TEMPLATES), str(target))
+            self.assertEqual(proc.returncode, 0, msg=proc.stderr)
+            charter = target / "support-agent.yaml"
+            self.assertTrue(charter.exists())
+            data = yaml.safe_load(charter.read_text())
+            self.assertEqual(data["id"], "support-agent")
+            self.assertEqual(data["trigger"]["type"], "cron")
+
+    def test_missing_template_is_reported_not_fatal(self):
+        with tempfile.TemporaryDirectory() as td:
+            target = Path(td) / "autonomous"
+            manifest = Path(td) / "manifest.yaml"
+            manifest.write_text(yaml.safe_dump({
+                "autonomous_agents": ["does-not-exist"],
+            }))
+            proc = _run("autonomous", str(manifest), str(TEMPLATES), str(target))
+            self.assertEqual(proc.returncode, 0)
+            self.assertIn("no template", proc.stdout)
+
+    def test_existing_charter_is_kept(self):
+        with tempfile.TemporaryDirectory() as td:
+            target = Path(td) / "autonomous"
+            target.mkdir()
+            # User-modified charter — installer must NOT clobber it.
+            (target / "support-agent.yaml").write_text("id: support-agent\ncustom: true\n")
+            manifest = Path(td) / "manifest.yaml"
+            manifest.write_text(yaml.safe_dump({
+                "autonomous_agents": ["support-agent"],
+            }))
+            proc = _run("autonomous", str(manifest), str(TEMPLATES), str(target))
+            self.assertEqual(proc.returncode, 0)
+            self.assertIn("already present", proc.stdout)
+            data = yaml.safe_load((target / "support-agent.yaml").read_text())
+            self.assertTrue(data.get("custom"))
+
+
+class TestRag(unittest.TestCase):
+    def test_rag_writes_config_yaml(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            home.mkdir()
+            manifest = Path(td) / "manifest.yaml"
+            manifest.write_text(yaml.safe_dump({
+                "options": {
+                    "rag": {
+                        "envelope": "corrective",
+                        "strategies": ["hybrid", "graph", "multimodal"],
+                    }
+                }
+            }))
+            proc = _run("rag", str(manifest), str(home))
+            self.assertEqual(proc.returncode, 0)
+            target = home / "Agentik_SSOT" / "rag" / "config.yaml"
+            self.assertTrue(target.exists())
+            data = yaml.safe_load(target.read_text())
+            self.assertEqual(data["envelope"], "corrective")
+            self.assertEqual(data["strategies"], ["hybrid", "graph", "multimodal"])
+
+
+class TestInitVault(unittest.TestCase):
+    def test_init_vault_runs_against_a_tree(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            (home / "Agentik_Engine").mkdir(parents=True)
+            # Symlink the real engine in so the helper can import it.
+            real_engine = REPO_ROOT / "omega" / "Agentik_Engine" / "omega_engine"
+            (home / "Agentik_Engine" / "omega_engine").symlink_to(real_engine)
+            proc = _run("init-vault", str(home))
+            self.assertEqual(proc.returncode, 0)
+            self.assertIn("vault backend:", proc.stdout)
+            self.assertTrue(
+                (home / "Agentik_Extra" / "etc" / "secrets").is_dir()
+            )
+
+
+class TestAccounts(unittest.TestCase):
+    def test_accounts_adds_to_pool_with_token(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            (home / "Agentik_Engine").mkdir(parents=True)
+            (home / "Agentik_Engine" / "omega_engine").symlink_to(
+                REPO_ROOT / "omega" / "Agentik_Engine" / "omega_engine"
+            )
+            manifest = Path(td) / "manifest.yaml"
+            manifest.write_text(yaml.safe_dump({
+                "accounts": [
+                    {"id": "max-primary", "label": "Primary",
+                     "token_env": "TEST_OAUTH_PRIMARY"},
+                    {"id": "max-secondary"},  # no token_env → uses default name
+                ],
+            }))
+            env = {**os.environ, "TEST_OAUTH_PRIMARY": "fake-oauth-token-xyz"}
+            proc = subprocess.run(
+                [sys.executable, str(HELPER), "accounts",
+                 str(manifest), str(home)],
+                check=False, capture_output=True, text=True, env=env, timeout=60,
+            )
+            self.assertEqual(proc.returncode, 0, msg=proc.stderr)
+            self.assertIn("token written from $TEST_OAUTH_PRIMARY", proc.stdout)
+            self.assertIn("max-secondary", proc.stdout)
+            self.assertIn("pool saved with 2 account(s)", proc.stdout)
+            # The token must round-trip through the vault.
+            sys.path.insert(0, str(home / "Agentik_Engine"))
+            from omega_engine.account import read_token  # type: ignore
+            self.assertEqual(
+                read_token(home, "CLAUDE_OAUTH_max-primary"),
+                "fake-oauth-token-xyz",
+            )
+
+
+class TestFirstProject(unittest.TestCase):
+    def test_first_project_creates_dir(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            (home / "Agentik_Engine").mkdir(parents=True)
+            (home / "Agentik_Engine" / "omega_engine").symlink_to(
+                REPO_ROOT / "omega" / "Agentik_Engine" / "omega_engine"
+            )
+            manifest = Path(td) / "manifest.yaml"
+            manifest.write_text(yaml.safe_dump({"first_project": "DemoOne"}))
+            env = {**os.environ, "OMEGA_HOME": str(home)}
+            proc = subprocess.run(
+                [sys.executable, str(HELPER), "first-project",
+                 str(manifest), str(home)],
+                check=False, capture_output=True, text=True, env=env, timeout=60,
+            )
+            self.assertEqual(proc.returncode, 0, msg=proc.stderr)
+            self.assertIn("created project 'DemoOne'", proc.stdout)
+            # The project dir was created somewhere under the home.
+            self.assertTrue(any(
+                p.is_dir() for p in (home / "Agentik_Coding").rglob("*")
+            ))
+
+    def test_first_project_is_idempotent(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            (home / "Agentik_Engine").mkdir(parents=True)
+            (home / "Agentik_Engine" / "omega_engine").symlink_to(
+                REPO_ROOT / "omega" / "Agentik_Engine" / "omega_engine"
+            )
+            manifest = Path(td) / "manifest.yaml"
+            manifest.write_text(yaml.safe_dump({"first_project": "AlreadyHere"}))
+            env = {**os.environ, "OMEGA_HOME": str(home)}
+            # First run creates the project.
+            subprocess.run(
+                [sys.executable, str(HELPER), "first-project",
+                 str(manifest), str(home)],
+                check=False, capture_output=True, text=True, env=env, timeout=60,
+            )
+            # Second run is a no-op.
+            proc = subprocess.run(
+                [sys.executable, str(HELPER), "first-project",
+                 str(manifest), str(home)],
+                check=False, capture_output=True, text=True, env=env, timeout=60,
+            )
+            self.assertEqual(proc.returncode, 0)
+            self.assertIn("already exists", proc.stdout)
+
+
+class TestMcpEncryption(unittest.TestCase):
+    @unittest.skipUnless(
+        shutil.which("age") and shutil.which("age-keygen"),
+        "age not installed",
+    )
+    def test_encrypt_mcp_env_real_value_moves_to_vault(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            (home / "Agentik_Engine").mkdir(parents=True)
+            (home / "Agentik_Engine" / "omega_engine").symlink_to(
+                REPO_ROOT / "omega" / "Agentik_Engine" / "omega_engine"
+            )
+            sec = home / "Agentik_Extra" / "etc" / "secrets"
+            sec.mkdir(parents=True)
+            (sec / "mcp-composio.env").write_text("COMPOSIO_API_KEY=real-key-123\n")
+            proc = subprocess.run(
+                [sys.executable, str(HELPER), "encrypt-mcp-env",
+                 str(home), "composio"],
+                check=False, capture_output=True, text=True, timeout=60,
+            )
+            self.assertEqual(proc.returncode, 0, msg=proc.stderr)
+            self.assertIn("encrypted mcp-composio.env", proc.stdout)
+            self.assertFalse((sec / "mcp-composio.env").exists())
+            self.assertTrue((sec / "mcp_composio_ENV.age").exists())
+
+    def test_encrypt_mcp_env_placeholder_is_left_alone(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            (home / "Agentik_Engine").mkdir(parents=True)
+            (home / "Agentik_Engine" / "omega_engine").symlink_to(
+                REPO_ROOT / "omega" / "Agentik_Engine" / "omega_engine"
+            )
+            sec = home / "Agentik_Extra" / "etc" / "secrets"
+            sec.mkdir(parents=True)
+            (sec / "mcp-github.env").write_text("# GITHUB_TOKEN=  # set later\n")
+            proc = subprocess.run(
+                [sys.executable, str(HELPER), "encrypt-mcp-env",
+                 str(home), "github"],
+                check=False, capture_output=True, text=True, timeout=60,
+            )
+            self.assertEqual(proc.returncode, 0)
+            # File still present, vault not written.
+            self.assertTrue((sec / "mcp-github.env").exists())
+
+
+class TestDoctorJSON(unittest.TestCase):
+    def test_doctor_json_produces_parseable_output(self):
+        import json as _json
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td) / "Omega"
+            # Minimal block tree so doctor doesn't barf.
+            for b in ["Agentik_SSOT", "Agentik_Engine", "Agentik_Orchestration",
+                      "Agentik_Providers", "Agentik_Coding", "Agentik_Tools",
+                      "Agentik_Runtime", "Agentik_Extra"]:
+                (home / b).mkdir(parents=True)
+            (home / "Agentik_Engine" / "omega_engine").symlink_to(
+                REPO_ROOT / "omega" / "Agentik_Engine" / "omega_engine"
+            )
+            env = {**os.environ, "OMEGA_HOME": str(home)}
+            proc = subprocess.run(
+                [sys.executable, "-m", "omega_engine.cli", "doctor", "--json"],
+                check=False, capture_output=True, text=True, env=env, timeout=60,
+                cwd=str(home / "Agentik_Engine"),
+            )
+            # Exit code may be 0 or 1, but stdout must be parseable JSON.
+            try:
+                data = _json.loads(proc.stdout)
+            except _json.JSONDecodeError as exc:
+                self.fail(f"doctor --json output not JSON: {exc}\nstdout: {proc.stdout[:500]}")
+            self.assertEqual(data["omega_home"], str(home))
+            self.assertIn("verdict", data)
+            self.assertIn("results", data)
+            self.assertIsInstance(data["results"], list)
+            # Each result has the expected shape.
+            for r in data["results"]:
+                self.assertIn("section", r)
+                self.assertIn("status", r)
+                self.assertIn("msg", r)
+                self.assertIn(r["status"], {"ok", "warn", "FAIL"})
+
+
+class TestInstallerWiring(unittest.TestCase):
+    """Each new step must be referenced by install.sh AND defined in steps.sh."""
+
+    def test_install_sh_runs_all_new_steps(self):
+        text = INSTALL_SH.read_text()
+        for step in (
+            "32-accounts", "step_accounts",
+            "35-providers", "step_providers",
+            "55-autonomous", "step_autonomous",
+            "57-rag", "step_rag",
+            "58-first-project", "step_first_project",
+        ):
+            self.assertIn(step, text, f"missing in install.sh: {step}")
+
+    def test_steps_sh_defines_new_step_functions(self):
+        text = STEPS_SH.read_text()
+        for fn in ("step_accounts()", "step_providers()", "step_autonomous()",
+                   "step_rag()", "step_first_project()",
+                   "_services_linux", "_services_macos", "_launchd_plist"):
+            self.assertIn(fn, text, f"missing in steps.sh: {fn}")
+
+    def test_step_services_enables_systemd(self):
+        text = STEPS_SH.read_text()
+        self.assertIn("systemctl --user enable --now", text)
+        self.assertIn("loginctl enable-linger", text)
+
+    def test_step_services_has_real_launchd_plists(self):
+        text = STEPS_SH.read_text()
+        self.assertNotIn("build-out", text)
+        self.assertIn("launchctl bootstrap", text)
+        self.assertIn("com.agentikos.omega.engine", text)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/omega/Agentik_Engine/tests/test_install_ux.py

@@ -0,0 +1,151 @@
+"""Smoke tests for the installer UX layer in bootstrap/lib/common.sh.
+
+These tests don't run the full installer — they source common.sh inside a
+controlled subshell, call individual helpers, and assert the printed output
+looks correct. Bash-side functions only; no actual install side-effects.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+COMMON_SH = REPO_ROOT / "bootstrap" / "lib" / "common.sh"
+
+
+def _bash(snippet: str, *, env: dict[str, str] | None = None,
+          stdin: str = "") -> tuple[int, str, str]:
+    """Run a bash snippet that sources common.sh; return (rc, stdout, stderr)."""
+    base_env = {**os.environ}
+    base_env.setdefault("OMEGA_REPO", str(REPO_ROOT))
+    base_env.setdefault("OMEGA_HOME", "/tmp/omega-ux-pytest")
+    base_env.setdefault("OMEGA_USER", "tester")
+    base_env.setdefault("LOG_FILE", "/tmp/omega-ux-pytest.log")
+    base_env.setdefault("NONINTERACTIVE", "1")
+    base_env.setdefault("PROFILE", "vps")
+    base_env.setdefault("PROFILE_EXPLICIT", "1")
+    base_env.setdefault("OMEGA_OS", "linux")
+    base_env.setdefault("OMEGA_PKG", "apt")
+    if env:
+        base_env.update(env)
+    # Run with `bash -lc` to get a proper login shell; force colours off so
+    # tests don't have to strip ANSI.
+    code = (
+        f"source '{COMMON_SH}'\n"
+        "C_OK=''; C_ERR=''; C_INFO=''; C_DIM=''; C_RST=''\n"
+        "C_BOLD=''; C_CYAN=''; C_GREEN=''; C_YELLOW=''; C_RED=''; C_MAGENTA=''; C_BLUE=''\n"
+        + snippet
+    )
+    proc = subprocess.run(
+        ["bash", "-c", code],
+        env=base_env, capture_output=True, text=True, input=stdin,
+        timeout=15,
+    )
+    return proc.returncode, proc.stdout, proc.stderr
+
+
+class TestBanner(unittest.TestCase):
+    def test_banner_includes_name_and_version(self):
+        rc, out, _ = _bash("install_banner")
+        self.assertEqual(rc, 0)
+        self.assertIn("Omega OS", out)
+        self.assertIn("agentik-os/OmegaOS", out)
+
+    def test_omega_version_reads_ssot_file(self):
+        rc, out, _ = _bash("omega_version")
+        self.assertEqual(rc, 0)
+        # Don't hardcode the version — read it from the SSOT file and
+        # require the banner to echo whatever's actually there.
+        repo = Path(__file__).resolve().parents[3]
+        ssot_version = (repo / "omega" / "Agentik_SSOT" / "VERSION").read_text().strip()
+        self.assertIn(ssot_version, out.strip())
+
+
+class TestPreflightCard(unittest.TestCase):
+    def test_lists_os_and_required_tools(self):
+        rc, out, _ = _bash("preflight_card")
+        self.assertEqual(rc, 0)
+        self.assertIn("pre-flight detection", out)
+        self.assertIn("required tools", out)
+        # All the required-tool ids must appear, regardless of host state
+        for tool in ("git", "python3", "tmux", "sqlite3", "curl", "jq"):
+            self.assertIn(tool, out)
+
+
+class TestStepProgress(unittest.TestCase):
+    def test_progress_header_increments_count(self):
+        rc, out, _ = _bash(
+            "STEP_TOTAL=3\nstep_progress_header step-a\n"
+            "step_progress_header step-b\nstep_progress_header step-c\n"
+        )
+        self.assertEqual(rc, 0)
+        self.assertIn("[1/3]", out)
+        self.assertIn("[2/3]", out)
+        self.assertIn("[3/3]", out)
+
+
+class TestPathSetup(unittest.TestCase):
+    def test_appends_marker_to_rc(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            rc_path = Path(tmp) / ".zshrc"
+            rc_path.write_text("# existing\n")
+            rc, out, _ = _bash(
+                "path_setup_user_rc",
+                env={"HOME": tmp, "SHELL": "/bin/zsh",
+                     "OMEGA_HOME": "/tmp/omega-pytest"},
+            )
+            self.assertEqual(rc, 0)
+            content = rc_path.read_text()
+            self.assertIn("# >>> omega-os >>>", content)
+            self.assertIn("export OMEGA_HOME=", content)
+            self.assertIn("Agentik_Tools/bin", content)
+
+    def test_idempotent_on_second_call(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            rc_path = Path(tmp) / ".bashrc"
+            rc_path.write_text("")
+            _bash("path_setup_user_rc",
+                  env={"HOME": tmp, "SHELL": "/bin/bash",
+                       "OMEGA_HOME": "/tmp/omega-pytest"})
+            first = rc_path.read_text()
+            _bash("path_setup_user_rc",
+                  env={"HOME": tmp, "SHELL": "/bin/bash",
+                       "OMEGA_HOME": "/tmp/omega-pytest"})
+            second = rc_path.read_text()
+            # Marker present exactly once in both reads.
+            self.assertEqual(first, second)
+            self.assertEqual(first.count("# >>> omega-os >>>"), 1)
+
+    def test_no_path_setup_flag_skips(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            rc_path = Path(tmp) / ".zshrc"
+            rc_path.write_text("# only this\n")
+            _bash("path_setup_user_rc",
+                  env={"HOME": tmp, "SHELL": "/bin/zsh",
+                       "OMEGA_HOME": "/tmp/omega-pytest",
+                       "NO_PATH_SETUP": "1"})
+            self.assertEqual(rc_path.read_text(), "# only this\n")
+
+
+class TestPostInstallCard(unittest.TestCase):
+    def test_card_includes_status_and_next_steps(self):
+        # omega CLI isn't on PATH inside the test sandbox → readiness=UNKNOWN
+        rc, out, _ = _bash("post_install_card")
+        self.assertEqual(rc, 0)
+        self.assertIn("Omega OS v", out)
+        self.assertIn("install complete", out)
+        self.assertIn("status", out)
+        self.assertIn("next steps", out)
+        self.assertIn("omega status", out)
+        self.assertIn("omega run", out)
+        # No literal $C_DIM / $C_RST tokens
+        self.assertNotIn("${C_DIM}", out)
+        self.assertNotIn("${C_RST}", out)
+
+
+if __name__ == "__main__":
+    unittest.main()