hermes-agent/tests/hermes_cli/test_config.py

"""Tests for hermes_cli configuration management."""

import os
from pathlib import Path
from unittest.mock import patch

import pytest
import yaml

from hermes_cli.config import (
    DEFAULT_CONFIG,
    check_config_version,
    get_hermes_home,
    ensure_hermes_home,
    get_compatible_custom_providers,
    _explicit_config_paths,
    _normalize_max_turns_config,
    is_provider_enabled,
    load_config,
    load_env,
    migrate_config,
    read_raw_config,
    remove_env_value,
    save_config,
    save_env_value,
    save_env_value_secure,
    sanitize_env_file,
    set_config_value,
    write_platform_config_field,
    _sanitize_env_lines,
)


class TestGetHermesHome:
    def test_default_path(self):
        with patch.dict(os.environ, {}, clear=False):
            os.environ.pop("HERMES_HOME", None)
            home = get_hermes_home()
            assert home == Path.home() / ".hermes"


class TestEnsureHermesHome:

    def test_creates_default_soul_md_if_missing(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            ensure_hermes_home()
            soul_path = tmp_path / "SOUL.md"
            assert soul_path.exists()
            assert soul_path.read_text(encoding="utf-8").strip() != ""


    def test_upgrades_legacy_template_soul_md(self, tmp_path):
        # Older installers seeded a comment-only scaffold that shadowed the
        # runtime default. A SOUL.md still matching that scaffold carries no
        # user persona and should be upgraded in place to DEFAULT_SOUL_MD.
        from hermes_cli.default_soul import DEFAULT_SOUL_MD, _LEGACY_TEMPLATE_SOULS

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            soul_path = tmp_path / "SOUL.md"
            soul_path.write_text(_LEGACY_TEMPLATE_SOULS[0] + "\n", encoding="utf-8")
            ensure_hermes_home()
            assert soul_path.read_text(encoding="utf-8") == DEFAULT_SOUL_MD





class TestLoadConfigDefaults:
    def test_returns_defaults_when_no_file(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            config = load_config()
            assert config["model"] == DEFAULT_CONFIG["model"]
            assert config["agent"]["max_turns"] == DEFAULT_CONFIG["agent"]["max_turns"]
            assert "max_turns" not in config
            assert "terminal" in config
            assert config["terminal"]["backend"] == "local"
            assert config["display"]["interim_assistant_messages"] is True

    def test_legacy_root_level_max_turns_migrates_to_agent_config(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            config_path = tmp_path / "config.yaml"
            config_path.write_text("max_turns: 42\n")

            config = load_config()
            assert config["agent"]["max_turns"] == 42
            assert "max_turns" not in config


class TestLoadConfigParseFailure:
    """A YAML parse failure must NOT silently fall back to defaults.

    Before issue #23570 this was a single ``print(...)`` that scrolled past
    on the first invocation — users saw aux-fallback misbehavior with no clue
    their config.yaml was being ignored. The helper must:
      * log at WARNING (so ``hermes logs`` surfaces it)
      * also write to stderr (so it's visible at startup even before
        ``setup_logging()`` has wired up file handlers)
      * dedup on (path, mtime_ns, size) so concurrent loads don't spam
      * re-warn after the user edits the file (different mtime)
    """




    def test_corrupt_config_is_backed_up(self, tmp_path, capsys):
        """A broken config.yaml is snapshotted to a timestamped .bak so the
        user's recoverable overrides survive a later wizard/config-set rewrite.

        Ported from google-gemini/gemini-cli#21541 (policy-file TOML recovery),
        adapted: we back up but deliberately do NOT reset config.yaml.
        """
        from hermes_cli import config as cfg_mod
        cfg_mod._CONFIG_PARSE_WARNED.clear()

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            broken = "\tmodel: test/custom\nbroken indent:\n"
            (tmp_path / "config.yaml").write_text(broken)

            load_config()
            err = capsys.readouterr().err

            baks = list(tmp_path.glob("config.yaml.corrupt.*.bak"))
            assert len(baks) == 1, f"expected one backup, got {baks}"
            # Backup preserves the original broken content verbatim
            assert baks[0].read_text() == broken
            # Original config.yaml is left untouched (not reset to clean state)
            assert (tmp_path / "config.yaml").read_text() == broken
            # User is told where the backup landed
            assert str(baks[0]) in err



    def test_last_known_good_retained_within_process(self, tmp_path, capsys):
        """Port of openai/codex#31188's invariant: a parse failure must not
        silently replace the effective config (policy included) with
        defaults when the process already loaded a good config.

        Scenario: long-running gateway, user mid-edits config.yaml into
        broken YAML. Before this fix the next load_config() dropped every
        override — including ``approvals.deny`` security rules. Now the
        last successfully loaded config keeps being served until the file
        parses again.
        """
        import time
        from hermes_cli import config as cfg_mod
        cfg_mod._CONFIG_PARSE_WARNED.clear()

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            cfg = tmp_path / "config.yaml"
            cfg.write_text(
                "model:\n  default: test/custom-model\n"
                "approvals:\n  deny:\n    - 'curl*evil.com*'\n"
            )

            good = load_config()
            assert good["model"]["default"] == "test/custom-model"
            assert good["approvals"]["deny"] == ["curl*evil.com*"]
            capsys.readouterr()

            # Corrupt the file (mtime must change to bust the cache)
            time.sleep(0.05)
            cfg.write_text("approvals:\n  deny: [unclosed\n  :::bad {{{\n")

            after = load_config()
            # Last-known-good retained — NOT defaults
            assert after["model"]["default"] == "test/custom-model"
            assert after["approvals"]["deny"] == ["curl*evil.com*"]
            # Warning says we kept the previous config, not defaults
            err = capsys.readouterr().err
            assert "previously loaded config" in err





class TestEmptyConfigSections:
    """Empty section keys (``terminal:`` with no value) parse as YAML None
    and must not replace the default dict for that section (#58277)."""

    def test_null_section_keeps_defaults_in_load_config(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            (tmp_path / "config.yaml").write_text(
                "model:\n  default: test/custom\n"
                "terminal:\n"
                "display:\n"
            )
            config = load_config()
            assert config["model"]["default"] == "test/custom"
            assert isinstance(config["terminal"], dict)
            assert config["terminal"] == DEFAULT_CONFIG["terminal"]
            assert isinstance(config["display"], dict)

    def test_null_override_of_non_dict_default_still_applies(self, tmp_path):
        """None only shields dict defaults — explicit null for a scalar
        key remains an override (unchanged behavior)."""
        from hermes_cli.config import _deep_merge

        merged = _deep_merge({"scalar": 5, "section": {"a": 1}},
                             {"scalar": None, "section": None})
        assert merged["scalar"] is None
        assert merged["section"] == {"a": 1}


class TestSaveAndLoadRoundtrip:
    @staticmethod
    def _deny_config_reads(config_path):
        real_open = open

        def fake_open(file, mode="r", *args, **kwargs):
            if Path(file) == config_path and "r" in mode:
                raise PermissionError("denied")
            return real_open(file, mode, *args, **kwargs)

        return fake_open

    def test_roundtrip(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            config = load_config()
            config["model"] = "test/custom-model"
            config["agent"]["max_turns"] = 42
            save_config(config)

            reloaded = load_config()
            assert reloaded["model"] == "test/custom-model"
            assert reloaded["agent"]["max_turns"] == 42

            saved = yaml.safe_load((tmp_path / "config.yaml").read_text())
            assert saved["agent"]["max_turns"] == 42
            assert "max_turns" not in saved

    def test_save_config_refuses_to_overwrite_unreadable_existing_config(self, tmp_path):
        config_path = tmp_path / "config.yaml"
        original = "model: test/original\n"
        config_path.write_text(original, encoding="utf-8")

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            with patch("builtins.open", side_effect=self._deny_config_reads(config_path)):
                with pytest.raises(RuntimeError, match="Refusing to overwrite"):
                    save_config({"model": "test/replacement"})

        assert config_path.read_text(encoding="utf-8") == original







class TestSaveEnvValueSecure:

    def test_secure_save_returns_metadata_only(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            result = save_env_value_secure("GITHUB_TOKEN", "ghp_test_secret")
            assert result == {
                "success": True,
                "stored_as": "GITHUB_TOKEN",
                "validated": False,
            }
            assert "secret" not in str(result).lower()



    def test_save_env_value_preserves_existing_file_mode_on_posix(self, tmp_path):
        """Regression for #31518: pre-existing .env mode (e.g. 0640 for a
        Docker bind-mount that the operator chose) survives subsequent
        writes. Previously _secure_file ran unconditionally after the
        mode-restore branch and re-tightened to 0600.
        """
        if os.name == "nt":
            return

        env_path = tmp_path / ".env"
        env_path.write_text("EXISTING=value\n")
        os.chmod(env_path, 0o640)

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            save_env_value("TENOR_API_KEY", "sk-test-secret")

        env_mode = env_path.stat().st_mode & 0o777
        assert env_mode == 0o640, f"expected 0o640, got {oct(env_mode)}"

    def test_save_env_value_quotes_values_containing_hash(self, tmp_path):
        """Regression test for #30355."""
        from dotenv import dotenv_values

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}, clear=False):
            os.environ.pop("ANTHROPIC_TOKEN", None)
            token = "sk-ant-oat01-abc#xyz#more"
            save_env_value("ANTHROPIC_TOKEN", token)

            content = (tmp_path / ".env").read_text(encoding="utf-8")
            assert f'ANTHROPIC_TOKEN="{token}"' in content

            parsed = dotenv_values(str(tmp_path / ".env"))
            assert parsed["ANTHROPIC_TOKEN"] == token
            assert load_env()["ANTHROPIC_TOKEN"] == token


    def test_save_env_value_already_quoted_input_is_not_double_wrapped_idempotently(
        self, tmp_path
    ):
        """Callers pass raw values; if a value literally contains quote
        characters, escaping+wrap is the dialect (#57249). Re-saving the
        same raw value is stable (no quote growth). load_env round-trips.
        """
        # User-typed value that already includes surrounding quotes as data.
        raw = '"/Users/me/Application Support/key"'
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}, clear=False):
            os.environ.pop("TERMINAL_SSH_KEY", None)
            save_env_value("TERMINAL_SSH_KEY", raw)
            first = (tmp_path / ".env").read_text(encoding="utf-8")
            save_env_value("TERMINAL_SSH_KEY", raw)
            second = (tmp_path / ".env").read_text(encoding="utf-8")
            assert first == second
            # One outer wrap layer only (escaped inner quotes, not nested wraps).
            line = [
                ln for ln in first.splitlines() if ln.startswith("TERMINAL_SSH_KEY=")
            ][0]
            assert line.startswith('TERMINAL_SSH_KEY="')
            assert line.endswith('"')
            assert line.count('TERMINAL_SSH_KEY="') == 1
            # Escaping dialect end-to-end: load sees the raw input, not stripped quotes.
            assert load_env()["TERMINAL_SSH_KEY"] == raw


class TestRemoveEnvValue:
    def test_removes_key_from_env_file(self, tmp_path):
        env_path = tmp_path / ".env"
        env_path.write_text("KEY_A=value_a\nKEY_B=value_b\nKEY_C=value_c\n")
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path), "KEY_B": "value_b"}):
            result = remove_env_value("KEY_B")
            assert result is True
            content = env_path.read_text()
            assert "KEY_B" not in content
            assert "KEY_A=value_a" in content
            assert "KEY_C=value_c" in content


    def test_clears_os_environ_even_when_not_in_file(self, tmp_path):
        env_path = tmp_path / ".env"
        env_path.write_text("OTHER=stuff\n")
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path), "ORPHAN_KEY": "orphan"}):
            remove_env_value("ORPHAN_KEY")
            assert "ORPHAN_KEY" not in os.environ

    def test_remove_env_value_preserves_existing_file_mode_on_posix(self, tmp_path):
        """Regression: pre-existing .env mode (e.g. 0640 for a Docker
        bind-mount the operator chose) survives a remove just as it does a
        save. Previously _secure_file ran unconditionally after the
        mode-restore branch and re-tightened to 0600 — the same bug fixed
        in save_env_value (#33699), in the sibling remove path.
        """
        if os.name == "nt":
            return

        env_path = tmp_path / ".env"
        env_path.write_text("KEEP=value\nDROP=gone\n")
        os.chmod(env_path, 0o640)

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path), "DROP": "gone"}):
            removed = remove_env_value("DROP")

        assert removed is True
        assert "DROP" not in env_path.read_text()
        env_mode = env_path.stat().st_mode & 0o777
        assert env_mode == 0o640, f"expected 0o640, got {oct(env_mode)}"


class TestSaveConfigAtomicity:
    """Verify save_config uses atomic writes (tempfile + os.replace)."""

    def test_no_partial_write_on_crash(self, tmp_path):
        """If save_config crashes mid-write, the previous file stays intact."""
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            # Write an initial config
            config = load_config()
            config["model"] = "original-model"
            save_config(config)

            config_path = tmp_path / "config.yaml"
            assert config_path.exists()

            # Simulate a crash during yaml.dump by making atomic_yaml_write's
            # yaml.dump raise after the temp file is created but before replace.
            with patch("utils.yaml.dump", side_effect=OSError("disk full")):
                try:
                    config["model"] = "should-not-persist"
                    save_config(config)
                except OSError:
                    pass

            # Original file must still be intact
            reloaded = load_config()
            assert reloaded["model"] == "original-model"

    def test_no_leftover_temp_files(self, tmp_path):
        """Failed writes must clean up their temp files."""
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            config = load_config()
            save_config(config)

            with patch("utils.yaml.dump", side_effect=OSError("disk full")):
                try:
                    save_config(config)
                except OSError:
                    pass

            # No .tmp files should remain
            tmp_files = list(tmp_path.glob(".*config*.tmp"))
            assert tmp_files == []

    def test_atomic_write_creates_valid_yaml(self, tmp_path):
        """The written file must be valid YAML matching the input."""
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            config = load_config()
            config["model"] = "test/atomic-model"
            config["agent"]["max_turns"] = 77
            save_config(config)

            # Read raw YAML to verify it's valid and correct
            config_path = tmp_path / "config.yaml"
            with open(config_path, encoding="utf-8") as f:
                raw = yaml.safe_load(f)
            assert raw["model"] == "test/atomic-model"
            assert raw["agent"]["max_turns"] == 77


class TestSanitizeEnvLines:
    """Tests for semantics-preserving .env line normalization."""





    def test_migrate_reports_normalized_line_formatting(self, capsys):
        latest_version = DEFAULT_CONFIG["_config_version"]
        with (
            patch("hermes_cli.config.sanitize_env_file", return_value=2),
            patch(
                "hermes_cli.config.check_config_version",
                return_value=(latest_version, latest_version),
            ),
            patch("hermes_cli.config.read_raw_config", return_value={}),
            patch("hermes_cli.config.get_missing_env_vars", return_value=[]),
            patch("hermes_cli.config.get_missing_config_fields", return_value=[]),
            patch("hermes_cli.config.get_missing_skill_config_vars", return_value=[]),
        ):
            migrate_config(interactive=False)

        assert capsys.readouterr().out == (
            "  ✓ Normalized .env line formatting (2 line(s) changed)\n"
        )





    def test_glm_suffix_collision_not_split(self):
        """GLM_API_KEY / GLM_BASE_URL must not be mangled by LM_API_KEY / LM_BASE_URL suffixes (#17138)."""
        lines = [
            "GLM_API_KEY=glm-secret\n",
            "GLM_BASE_URL=https://api.z.ai/api/paas/v4\n",
        ]
        result = _sanitize_env_lines(lines)
        assert result == lines, f"GLM_* lines were corrupted by suffix collision: {result}"






    def test_sanitize_env_file_does_not_rewrite_value_semantics(self, tmp_path):
        env_file = tmp_path / ".env"
        env_file.write_text(
            "FAL_KEY=good\n"
            "OPENROUTER_API_KEY=valFIRECRAWL_API_KEY=val2\n"
        )
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            fixes = sanitize_env_file()
            assert fixes == 0

            content = env_file.read_text()
            assert content == (
                "FAL_KEY=good\n"
                "OPENROUTER_API_KEY=valFIRECRAWL_API_KEY=val2\n"
            )

    def test_sanitize_env_file_noop_on_clean_file(self, tmp_path):
        """No changes when file is already clean."""
        env_file = tmp_path / ".env"
        env_file.write_text("GOOD_KEY=good\nOTHER_KEY=other\n")
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            fixes = sanitize_env_file()
            assert fixes == 0


class TestOptionalEnvVarsRegistry:
    """Verify that key env vars are registered in OPTIONAL_ENV_VARS."""

    def test_tavily_api_key_registered(self):
        """TAVILY_API_KEY is listed in OPTIONAL_ENV_VARS."""
        from hermes_cli.config import OPTIONAL_ENV_VARS
        assert "TAVILY_API_KEY" in OPTIONAL_ENV_VARS


    def test_tavily_api_key_has_url(self):
        """TAVILY_API_KEY has a URL."""
        from hermes_cli.config import OPTIONAL_ENV_VARS
        assert OPTIONAL_ENV_VARS["TAVILY_API_KEY"]["url"] == "https://app.tavily.com/home"

    def test_tavily_in_env_vars_by_version(self):
        """TAVILY_API_KEY is listed in ENV_VARS_BY_VERSION."""
        from hermes_cli.config import ENV_VARS_BY_VERSION
        all_vars = []
        for vars_list in ENV_VARS_BY_VERSION.values():
            all_vars.extend(vars_list)
        assert "TAVILY_API_KEY" in all_vars

    def test_max_iterations_not_offered_as_env_var(self):
        """HERMES_MAX_ITERATIONS must NOT be in OPTIONAL_ENV_VARS (issue #17534).

        Offering it as an editable env var (dashboard, `hermes setup`) lets a
        user write it to .env, recreating the stale ghost that shadows
        config.yaml's agent.max_turns. The iteration budget is configured ONLY
        via config.yaml; HERMES_MAX_ITERATIONS remains a read-only backward-compat
        fallback in the gateway/CLI, never a promoted write target.
        """
        from hermes_cli.config import OPTIONAL_ENV_VARS
        assert "HERMES_MAX_ITERATIONS" not in OPTIONAL_ENV_VARS


class TestMemoryProviderEnvVarsRegistry:
    """Every memory provider that reads an API key from the environment must
    have that key catalogued in OPTIONAL_ENV_VARS so the dashboard Keys page
    and `hermes setup` surface it (previously only Honcho was listed, leaving
    Hindsight/Supermemory/Mem0/RetainDB/ByteRover/OpenViking invisible).

    This is a behavior contract, not a snapshot: it asserts each provider's
    primary credential key is present, tool-categorised, and password-masked —
    not a frozen count of entries.
    """

    # provider primary-credential env key -> the tool-call name it powers.
    MEMORY_PROVIDER_KEYS = {
        "HONCHO_API_KEY": "honcho_context",
        "HINDSIGHT_API_KEY": "hindsight_recall",
        "SUPERMEMORY_API_KEY": "supermemory_search",
        "MEM0_API_KEY": "mem0_search",
        "RETAINDB_API_KEY": "retaindb_search",
        "BRV_API_KEY": "brv_query",
        "OPENVIKING_API_KEY": "viking_search",
    }

    def test_memory_provider_keys_are_catalogued(self):
        from hermes_cli.config import OPTIONAL_ENV_VARS
        missing = [k for k in self.MEMORY_PROVIDER_KEYS if k not in OPTIONAL_ENV_VARS]
        assert not missing, f"memory provider keys missing from OPTIONAL_ENV_VARS: {missing}"


    def test_memory_provider_keys_advertise_their_tool(self):
        from hermes_cli.config import OPTIONAL_ENV_VARS
        for key, tool in self.MEMORY_PROVIDER_KEYS.items():
            assert tool in OPTIONAL_ENV_VARS[key].get("tools", []), key


class TestConfigMigrationSecretPrompts:
    def test_required_secret_env_prompt_uses_masked_prompt(self, tmp_path, monkeypatch):
        from hermes_cli import config as cfg_mod

        saved = {}

        monkeypatch.setattr(cfg_mod, "sanitize_env_file", lambda: 0)
        monkeypatch.setattr(cfg_mod, "check_config_version", lambda: (999, 999))
        monkeypatch.setattr(cfg_mod, "get_missing_config_fields", lambda: [])
        monkeypatch.setattr(cfg_mod, "get_missing_skill_config_vars", lambda: [])
        monkeypatch.setattr(
            cfg_mod,
            "get_missing_env_vars",
            lambda required_only=True: [
                {
                    "name": "TEST_API_KEY",
                    "description": "Test key",
                    "prompt": "Test API key",
                    "password": True,
                }
            ]
            if required_only
            else [],
        )
        def fake_masked_secret_prompt(prompt):
            saved["prompt"] = prompt
            return "secret"

        monkeypatch.setattr(cfg_mod, "masked_secret_prompt", fake_masked_secret_prompt)
        monkeypatch.setattr(
            cfg_mod,
            "save_env_value",
            lambda name, value: saved.update({name: value}),
        )

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            results = cfg_mod.migrate_config(interactive=True, quiet=True)

        assert saved["prompt"] == "  Test API key: "
        assert saved["TEST_API_KEY"] == "secret"
        assert results["env_added"] == ["TEST_API_KEY"]


class TestConfigVersionDetection:
    def test_check_config_version_uses_raw_on_disk_version(self, tmp_path):
        config_path = tmp_path / "config.yaml"
        config_path.write_text("model: {}\n", encoding="utf-8")

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            assert load_config()["_config_version"] == DEFAULT_CONFIG["_config_version"]
            assert check_config_version() == (0, DEFAULT_CONFIG["_config_version"])


class TestAnthropicTokenMigration:
    """Test that config version 8→9 clears ANTHROPIC_TOKEN."""

    def _write_config_version(self, tmp_path, version):
        config_path = tmp_path / "config.yaml"
        import yaml
        config_path.write_text(yaml.safe_dump({"_config_version": version}))

    def test_clears_token_on_upgrade_to_v9(self, tmp_path):
        """ANTHROPIC_TOKEN is cleared unconditionally when upgrading to v9."""
        self._write_config_version(tmp_path, 8)
        (tmp_path / ".env").write_text("ANTHROPIC_TOKEN=old-token\n")
        with patch.dict(os.environ, {
            "HERMES_HOME": str(tmp_path),
            "ANTHROPIC_TOKEN": "old-token",
        }):
            migrate_config(interactive=False, quiet=True)
            assert load_env().get("ANTHROPIC_TOKEN") == ""


class TestCustomProviderCompatibility:
    """Custom provider compatibility across legacy and v12+ config schemas."""



    def test_providers_dict_resolves_at_runtime(self, tmp_path):
        """After migration deleted custom_providers, get_compatible_custom_providers
        still finds entries from the providers dict."""
        config_path = tmp_path / "config.yaml"
        config_path.write_text(
            yaml.safe_dump(
                {
                    "_config_version": 17,
                    "providers": {
                        "openai-direct": {
                            "api": "https://api.openai.com/v1",
                            "api_key": "test-key",
                            "default_model": "gpt-5-mini",
                            "name": "OpenAI Direct",
                            "transport": "codex_responses",
                        }
                    },
                }
            ),
            encoding="utf-8",
        )

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            compatible = get_compatible_custom_providers()

        assert len(compatible) == 1
        assert compatible[0]["name"] == "OpenAI Direct"
        assert compatible[0]["base_url"] == "https://api.openai.com/v1"
        assert compatible[0]["provider_key"] == "openai-direct"
        assert compatible[0]["api_mode"] == "codex_responses"


    def test_compatible_custom_providers_prefers_base_url_then_url_then_api(self, tmp_path):
        """URL field precedence is base_url > url > api (PR #9332)."""
        config_path = tmp_path / "config.yaml"
        config_path.write_text(
            yaml.safe_dump(
                {
                    "_config_version": 17,
                    "providers": {
                        "my-provider": {
                            "name": "My Provider",
                            "api": "https://api.example.com/v1",
                            "url": "https://url.example.com/v1",
                            "base_url": "https://base.example.com/v1",
                        }
                    },
                }
            ),
            encoding="utf-8",
        )

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            compatible = get_compatible_custom_providers()

        assert compatible == [
            {
                "name": "My Provider",
                "base_url": "https://base.example.com/v1",
                "provider_key": "my-provider",
            }
        ]


class TestInterimAssistantMessageConfig:
    """Test the explicit gateway interim-message config gate."""

    def test_default_config_enables_interim_assistant_messages(self):
        assert DEFAULT_CONFIG["display"]["interim_assistant_messages"] is True

    def test_migrate_to_v15_adds_interim_assistant_message_gate(self, tmp_path):
        config_path = tmp_path / "config.yaml"
        config_path.write_text(
            yaml.safe_dump({"_config_version": 14, "display": {"tool_progress": "off"}}),
            encoding="utf-8",
        )

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            migrate_config(interactive=False, quiet=True)
            raw = yaml.safe_load(config_path.read_text(encoding="utf-8"))
            loaded = load_config()

        from hermes_cli.config import DEFAULT_CONFIG
        assert raw["_config_version"] == DEFAULT_CONFIG["_config_version"]
        # The user's explicit non-default value is preserved on disk.
        assert raw["display"]["tool_progress"] == "off"
        # interim_assistant_messages defaults to True and merges in transparently
        # at read time, so the migration must NOT materialise it to disk (that
        # was the config-bloat bug). It is still effective via load_config().
        assert "interim_assistant_messages" not in raw.get("display", {})
        assert loaded["display"]["interim_assistant_messages"] is True


class TestCliRefreshIntervalConfig:
    """Test the CLI refresh_interval config default (#45592 / #48309)."""

    def test_default_config_enables_cli_refresh_interval(self):
        """cli_refresh_interval defaults to 1.0 so the idle status-bar
        clock keeps ticking and the bottom chrome stays alive during
        idle (#45592). Users on emulators where the periodic redraw
        fights auto-scroll can set it to 0 (#48309)."""
        assert DEFAULT_CONFIG["display"]["cli_refresh_interval"] == 1.0


class TestDiscordChannelPromptsConfig:


    def test_migrate_preserves_custom_providers_and_no_defaults_dump(self, tmp_path):
        """Migration must not expand config.yaml to a defaults dump (#40821).

        Before the fix, migrations used load_config() which deep-merges
        DEFAULT_CONFIG, then save_config() wrote the full ~13KB expanded
        result — destroying comments and structure. Using read_raw_config()
        keeps the file small and preserves only the user's actual config.
        """
        config_path = tmp_path / "config.yaml"
        config_path.write_text(
            yaml.safe_dump({
                "_config_version": 3,
                "model": {"default": "test-model", "provider": "openrouter"},
                "custom_providers": [
                    {"name": "local-llm", "base_url": "http://localhost:8080/v1",
                     "models": {"test": {}}}
                ],
            }),
            encoding="utf-8",
        )

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            migrate_config(interactive=False, quiet=True)
            raw = yaml.safe_load(config_path.read_text(encoding="utf-8"))

        # custom_providers migrated to providers dict (by design, v11->v12)
        assert "custom_providers" not in raw
        assert "providers" in raw
        assert "local-llm" in raw["providers"]
        assert raw["providers"]["local-llm"]["api"] == "http://localhost:8080/v1"

        # File must NOT be a defaults dump — assert specific DEFAULT_CONFIG
        # top-level keys are absent (they should only appear via load_config's
        # deep-merge, not be written to the user's file by migration).
        for default_key in ("tts", "compression", "security", "whatsapp", "bedrock"):
            assert default_key not in raw, (
                f"{default_key} should not be in migrated config file — "
                f"migration should use read_raw_config() to avoid defaults dump"
            )


class TestEnvWriteDenylist:
    """``save_env_value`` refuses to persist env-var names that
    influence how subprocesses execute — ``LD_PRELOAD``, ``PYTHONPATH``,
    ``PATH``, ``EDITOR``, etc. — or any ``HERMES_*`` runtime flag.

    The dashboard exposes ``PUT /api/env`` to any authed caller (and
    the session token lives in the SPA's HTML where any future plugin
    XSS or local process could exfiltrate it). Without this gate, an
    attacker who steals the token could plant
    ``LD_PRELOAD=/tmp/evil.so`` in ``.env`` and own the next Hermes
    process on next startup via the dotenv → ``os.environ`` chain in
    ``hermes_cli/env_loader.py``.

    Regression test for the dashboard pentest finding filed alongside
    the ``web-pentest`` skill (PR #32265 / issue #32267).
    """

    @pytest.fixture(autouse=True)
    def _hermes_home(self, tmp_path, monkeypatch):
        monkeypatch.setenv("HERMES_HOME", str(tmp_path))
        ensure_hermes_home()


    @pytest.mark.parametrize(
        "allowed_key",
        [
            "HERMES_LANGFUSE_PUBLIC_KEY",
            "HERMES_SPOTIFY_CLIENT_ID",
            "HERMES_QWEN_BASE_URL",
            "HERMES_MAX_ITERATIONS",
        ],
    )
    def test_hermes_integration_keys_still_writable(self, allowed_key):
        """``HERMES_*`` overall is NOT blocked — only the four runtime
        location names (HOME/PROFILE/CONFIG/ENV) are. Integration
        credentials following the ``HERMES_*`` convention must keep
        working or we'd regress every provider setup wizard that
        currently writes one of these (auth.py, Spotify, Langfuse, …)."""
        save_env_value(allowed_key, "test-value-123")
        env = load_env()
        assert env[allowed_key] == "test-value-123"



    def test_save_env_value_secure_inherits_denylist(self):
        """The ``_secure`` variant goes through ``save_env_value`` so
        it inherits the gate — verify, don't assume."""
        with pytest.raises(ValueError, match="denylist"):
            save_env_value_secure("LD_PRELOAD", "/tmp/evil.so")



class TestWriteApprovalMigration:
    """Version 28→29 renames memory/skills write_mode → write_approval (bool).

    Only an explicit ``approve`` carried gating intent and maps to ``True``;
    ``on``/``off``/unset map to ``False`` (gate off). The old ``write_mode`` key
    is removed. Only a persisted key is rewritten — never invented.
    """

    def _write(self, tmp_path, body: str):
        (tmp_path / "config.yaml").write_text(body)

    def test_approve_maps_to_true(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            self._write(tmp_path,
                        "_config_version: 28\nmemory:\n  write_mode: approve\n"
                        "skills:\n  write_mode: approve\n")
            migrate_config(interactive=False, quiet=True)
            raw = yaml.safe_load((tmp_path / "config.yaml").read_text())
            assert raw["memory"]["write_approval"] is True
            assert raw["skills"]["write_approval"] is True
            assert "write_mode" not in raw["memory"]
            assert "write_mode" not in raw["skills"]

    def test_on_and_off_map_to_false(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            # YAML 1.1 parses bare on/off as bools — write_mode could be either
            # the string or the bool; both legacy "not gating" values → False.
            self._write(tmp_path,
                        "_config_version: 28\nmemory:\n  write_mode: 'on'\n"
                        "skills:\n  write_mode: 'off'\n")
            migrate_config(interactive=False, quiet=True)
            raw = yaml.safe_load((tmp_path / "config.yaml").read_text())
            loaded = load_config()
            # write_approval=False equals the schema default, so it is NOT
            # materialised to disk (lean-config invariant) — the legacy
            # write_mode key is gone and the effective value resolves to False
            # via load_config()'s deep-merge.
            assert "write_mode" not in raw.get("memory", {})
            assert "write_mode" not in raw.get("skills", {})
            assert loaded["memory"]["write_approval"] is False
            assert loaded["skills"]["write_approval"] is False


class TestMigrationWriteInvariant:
    """Architectural guard: every migration write routes through the single
    _persist_migration() chokepoint, which strips schema defaults so a lean
    config is never bloated into a DEFAULT_CONFIG dump on a version bump.

    These lock the centralised invariant so a future migration that calls
    save_config(...) directly (re-introducing the config-bloat bug class) is
    caught immediately.
    """


    @pytest.mark.parametrize("start_version", [1, "latest_minus_one"])
    def test_version_bump_keeps_config_lean(self, tmp_path, start_version):
        """A lean config migrated to the latest version must never be rewritten
        into a defaults dump — neither across the whole range (start=1, where
        per-version seeds also fire) nor on a bare one-version bump (where only
        the catch-all finalizer runs). In both cases no default-only top-level
        section the user never wrote may land on disk, the merged view still
        exposes every default, and the user's explicit non-default value
        survives.
        """
        latest = DEFAULT_CONFIG["_config_version"]
        start = latest - 1 if start_version == "latest_minus_one" else start_version
        config_path = tmp_path / "config.yaml"
        config_path.write_text(
            yaml.safe_dump({
                "_config_version": start,
                "model": {"default": "test-model", "provider": "openrouter"},
                "matrix": {"require_mention": False},
            }, sort_keys=False),
            encoding="utf-8",
        )
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            migrate_config(interactive=False, quiet=True)
            raw = yaml.safe_load(config_path.read_text(encoding="utf-8"))
            loaded = load_config()

        assert raw["_config_version"] == latest
        # User's explicit non-default value preserved (not reset to True default).
        assert raw["matrix"]["require_mention"] is False
        assert loaded["matrix"]["require_mention"] is False
        # No default-only top-level section the user never wrote lands on disk —
        # neither from per-version seeds nor the catch-all finalizer.
        for default_key in (
            "timezone", "curator", "auxiliary", "tts", "compression",
            "whatsapp", "bedrock",
        ):
            assert default_key not in raw, (
                f"{default_key} was materialised into a lean config by the "
                f"version bump — the default-dump regression returned"
            )
        # Defaults still take effect transparently via the read-time merge.
        assert loaded["curator"]["enabled"] == DEFAULT_CONFIG["curator"]["enabled"]
        assert loaded["display"]["compact"] == DEFAULT_CONFIG["display"]["compact"]


class TestSaveConfigPartialWritePreservation:
    """Regression for #62723: partial migration writes must not drop unrelated sections."""

    def test_merge_existing_preserves_platforms_on_partial_write(self, tmp_path):
        body = """_config_version: 30
model:
  default: deepseek-v4-pro
  provider: deepseek
agent:
  max_turns: 60
platforms:
  feishu:
    enabled: true
    extra:
      app_id: cli_xxx
      app_secret: xxx
feishu:
  require_mention: true
"""
        (tmp_path / "config.yaml").write_text(body, encoding="utf-8")
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            save_config(
                {
                    "_config_version": 30,
                    "model": {"default": "deepseek-v4-pro", "provider": "deepseek"},
                    "agent": {"max_turns": 60, "verify_on_stop": False},
                },
                merge_existing=True,
            )
            raw = yaml.safe_load((tmp_path / "config.yaml").read_text(encoding="utf-8"))

        assert raw["platforms"]["feishu"]["extra"]["app_id"] == "cli_xxx"
        assert raw["feishu"]["require_mention"] is True
        assert raw["agent"]["verify_on_stop"] is False


    def test_persist_migration_writes_full_read_raw_config(self, tmp_path):
        from hermes_cli.config import _persist_migration, read_raw_config

        body = """_config_version: 30
model:
  default: deepseek-v4-pro
  provider: deepseek
agent:
  max_turns: 60
platforms:
  feishu:
    enabled: true
    extra:
      app_id: cli_xxx
      app_secret: xxx
"""
        (tmp_path / "config.yaml").write_text(body, encoding="utf-8")
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            config = read_raw_config()
            config.setdefault("agent", {})["verify_on_stop"] = False
            config["_config_version"] = 32
            _persist_migration(config)
            raw = yaml.safe_load((tmp_path / "config.yaml").read_text(encoding="utf-8"))

        assert raw["platforms"]["feishu"]["extra"]["app_id"] == "cli_xxx"
        assert raw["agent"]["verify_on_stop"] is False
        assert raw["agent"]["max_turns"] == 60
        assert raw["_config_version"] == 32

    def test_v30_to_latest_migration_keeps_platforms(self, tmp_path):
        """End-to-end: reporter's v30 feishu profile survives version bump."""
        body = """_config_version: 30
model:
  default: deepseek-v4-pro
  provider: deepseek
agent:
  max_turns: 60
platforms:
  feishu:
    enabled: true
    extra:
      app_id: cli_xxx
      app_secret: xxx
feishu:
  require_mention: true
"""
        (tmp_path / "config.yaml").write_text(body, encoding="utf-8")
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            migrate_config(interactive=False, quiet=True)
            raw = yaml.safe_load((tmp_path / "config.yaml").read_text(encoding="utf-8"))

        assert raw["platforms"]["feishu"]["extra"]["app_id"] == "cli_xxx"
        assert raw["feishu"]["require_mention"] is True


class TestVerifyOnStopMigration:
    """v30 → v31: switch verify_on_stop OFF once, preserving explicit choices."""

    def _write(self, tmp_path, body):
        (tmp_path / "config.yaml").write_text(body, encoding="utf-8")


class TestDelegationCapUnificationMigration:
    """v32 → v33: fold deprecated max_async_children into max_concurrent_children."""

    def _write(self, tmp_path, body):
        (tmp_path / "config.yaml").write_text(body, encoding="utf-8")


    def test_no_delegation_section_is_noop(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            self._write(tmp_path, "_config_version: 32\nmodel:\n  provider: openrouter\n")
            migrate_config(interactive=False, quiet=True)
            raw = yaml.safe_load((tmp_path / "config.yaml").read_text())
        # Migration must not materialize a delegation section it never had.
        assert "delegation" not in raw


class TestConfigNormalizationDoesNotOverwriteUserValues:
    """Regression tests for #27354."""

    def test_save_config_does_not_inject_max_turns_when_unset(self, tmp_path):
        config_path = tmp_path / "config.yaml"
        config_path.write_text(
            yaml.safe_dump(
                {
                    "_config_version": DEFAULT_CONFIG["_config_version"],
                    "memory": {"user_char_limit": 2200},
                }
            ),
            encoding="utf-8",
        )

        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            save_config(load_config())
            raw = yaml.safe_load(config_path.read_text(encoding="utf-8"))

        assert "max_turns" not in raw.get("agent", {})
        assert raw["memory"]["user_char_limit"] == 2200



    def test_normalize_max_turns_does_not_inject_default(self):
        result = _normalize_max_turns_config(
            {"_config_version": DEFAULT_CONFIG["_config_version"]}
        )
        assert "max_turns" not in result.get("agent", {})




class TestCodexAppServerAutoConfig:
    """codex_app_server_auto ships a default and survives migration untouched."""

    def _write(self, tmp_path, body):
        (tmp_path / "config.yaml").write_text(body, encoding="utf-8")

    def test_default_config_has_native_mode(self):
        assert DEFAULT_CONFIG["compression"]["codex_app_server_auto"] == "native"
        assert DEFAULT_CONFIG["compression"]["codex_gpt55_autoraise"] is True

    def test_preserves_existing_codex_app_server_auto_value(self, tmp_path):
        with patch.dict(os.environ, {"HERMES_HOME": str(tmp_path)}):
            self._write(
                tmp_path,
                "_config_version: 31\n"
                "compression:\n"
                "  codex_app_server_auto: hermes\n",
            )

            migrate_config(interactive=False, quiet=True)

            raw = yaml.safe_load((tmp_path / "config.yaml").read_text())
            assert raw["compression"]["codex_app_server_auto"] == "hermes"


class TestIsProviderEnabled:
    """``is_provider_enabled`` gates ``providers.<name>`` blocks for the
    model picker, ``/models`` listings and the runtime resolver. Default
    must be ``True`` so existing configs keep working untouched."""

    def test_missing_flag_defaults_to_enabled(self):
        assert is_provider_enabled({"name": "Anthropic"}) is True


    @pytest.mark.parametrize("raw", ["true", "True", "yes", "on", "1", "anything-else"])
    def test_yaml_string_truthy_values_keep_it_enabled(self, raw):
        assert is_provider_enabled({"enabled": raw}) is True

    def test_non_dict_input_defaults_to_enabled(self):
        # Malformed entries (None, list, string) don't disappear silently —
        # the gate stays open and the existing validation paths will flag
        # them.
        assert is_provider_enabled(None) is True
        assert is_provider_enabled([]) is True
        assert is_provider_enabled("oops") is True


class TestProviderEnabledRuntimeGate:
    """Verify ``resolve_runtime_provider`` honours ``enabled: false`` for
    both custom-defined and built-in provider names. Smoke test only —
    full runtime resolution has its own fixture-heavy tests; here we
    only assert the early-exit raises a typed error."""

    def test_disabled_custom_provider_raises_valueerror(self, tmp_path, monkeypatch):
        cfg = {
            "model": {"default": "claude-sonnet-4-6", "provider": "claude-agent-sdk"},
            "providers": {
                "my-fork": {
                    "name": "my-fork",
                    "base_url": "http://127.0.0.1:9999",
                    "api_key": "not-needed",
                    "enabled": False,
                },
            },
        }
        config_path = tmp_path / "config.yaml"
        config_path.write_text(yaml.safe_dump(cfg))
        monkeypatch.setenv("HERMES_HOME", str(tmp_path))
        # Bust the in-process config cache so the override picks up.
        from hermes_cli import config as cfg_mod
        cfg_mod._cached_config = None  # type: ignore[attr-defined]

        from hermes_cli.runtime_provider import resolve_runtime_provider
        with pytest.raises(ValueError, match="disabled"):
            resolve_runtime_provider(requested="my-fork")


# ---------------------------------------------------------------------------
# DEFAULT_CONFIG must not carry a duplicate "kanban" key
# ---------------------------------------------------------------------------

def test_default_config_kanban_block_not_dropped_by_duplicate_key():
    """DEFAULT_CONFIG previously declared ``"kanban"`` twice, so Python kept
    only the second literal and silently dropped the first — losing the
    ``auto_subscribe_on_create`` default. Both sets of defaults must survive.
    """
    kanban = DEFAULT_CONFIG["kanban"]
    # From the first (dropped) block:
    assert kanban.get("auto_subscribe_on_create") is True
    # From the second block:
    assert "dispatch_in_gateway" in kanban
    assert "auto_decompose" in kanban


def test_default_config_has_no_duplicate_top_level_keys():
    """Guard against any duplicate key silently shadowing a default."""
    import ast
    import hermes_cli.config as cfg_mod

    src = open(cfg_mod.__file__, encoding="utf-8").read()
    tree = ast.parse(src)
    for node in ast.walk(tree):
        if isinstance(node, ast.Dict):
            keys = [k.value for k in node.keys if isinstance(k, ast.Constant)]
            if "model" in keys and "kanban" in keys:  # the DEFAULT_CONFIG literal
                dupes = {k for k in keys if keys.count(k) > 1}
                assert not dupes, f"duplicate DEFAULT_CONFIG keys: {sorted(dupes)}"