hermes-vault-secret-source 0.1.0__tar.gz

hermes_vault_secret_source-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cryptoyasenka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hermes_vault_secret_source-0.1.0/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: hermes-vault-secret-source
+Version: 0.1.0
+Summary: HashiCorp Vault secret source for Hermes Agent (bulk KV v2).
+Author: cryptoyasenka
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cryptoyasenka/hermes-vault-secret-source
+Project-URL: Repository, https://github.com/cryptoyasenka/hermes-vault-secret-source
+Project-URL: Issues, https://github.com/cryptoyasenka/hermes-vault-secret-source/issues
+Keywords: hermes,hermes-agent,vault,hashicorp,secrets,plugin
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: hvac>=2.0
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# hermes-vault-secret-source
+
+[![CI](https://github.com/cryptoyasenka/hermes-vault-secret-source/actions/workflows/ci.yml/badge.svg)](https://github.com/cryptoyasenka/hermes-vault-secret-source/actions/workflows/ci.yml)
+
+A [HashiCorp Vault](https://developer.hashicorp.com/vault) secret source for
+[Hermes Agent](https://github.com/NousResearch/hermes-agent), packaged as a
+standalone pip plugin.
+
+At Hermes startup it reads one Vault **KV v2** secret path and injects every
+key found there as an environment variable, the same way the bundled Bitwarden
+Secrets Manager source injects a whole project. This is a **bulk** source, so
+explicit per-variable bindings from mapped sources (like 1Password) take
+precedence over it.
+
+## Install
+
+```bash
+pip install "hermes-vault-secret-source @ git+https://github.com/cryptoyasenka/hermes-vault-secret-source"
+```
+
+The package is not on PyPI yet, so install it straight from the repository as
+shown above. Once it is published, this simplifies to:
+
+```bash
+pip install hermes-vault-secret-source
+```
+
+Either way this pulls in [`hvac`](https://hvac.readthedocs.io/), the official
+Python client for Vault. Install it into the same environment as `hermes-agent`.
+
+Hermes discovers the plugin automatically through the `hermes_agent.plugins`
+entry point, but plugins are opt-in. Enable it once:
+
+```bash
+hermes plugins enable hermes-hashicorp-vault
+```
+
+## Configure
+
+Add a `vault` block under `secrets` in your Hermes config:
+
+```yaml
+secrets:
+  vault:
+    enabled: true
+    # addr is read from $VAULT_ADDR by default; set `addr` to hard-code it.
+    path: apps/my-agent          # KV v2 path whose keys become env vars
+    mount_point: secret          # KV v2 mount (default: secret)
+    auth_method: token           # "token" (default) or "approle"
+    cache_ttl_seconds: 300       # 0 disables caching
+```
+
+Credentials are never written into config; they come from environment
+variables:
+
+| Auth method | Env vars used                                    |
+|-------------|--------------------------------------------------|
+| `token`     | `VAULT_ADDR`, `VAULT_TOKEN`                       |
+| `approle`   | `VAULT_ADDR`, `VAULT_ROLE_ID`, `VAULT_SECRET_ID` |
+
+The env-var names are overridable per field (`addr_env`, `token_env`,
+`role_id_env`, `secret_id_env`) if your deployment uses different names.
+
+### All config keys
+
+| Key                       | Default        | Meaning                                         |
+|---------------------------|----------------|-------------------------------------------------|
+| `enabled`                 | `false`        | Master switch                                   |
+| `addr`                    | `""`           | Vault URL; overrides `addr_env` when set        |
+| `addr_env`                | `VAULT_ADDR`   | Env var holding the Vault URL                   |
+| `path`                    | `""`           | KV v2 path to read (required)                   |
+| `mount_point`             | `secret`       | KV v2 secrets-engine mount                      |
+| `auth_method`             | `token`        | `token` or `approle`                            |
+| `token_env`               | `VAULT_TOKEN`  | Env var with the token (token auth)             |
+| `role_id_env`             | `VAULT_ROLE_ID`| Env var with the role_id (approle)              |
+| `secret_id_env`           | `VAULT_SECRET_ID` | Env var with the secret_id (approle)         |
+| `namespace`               | `""`           | Vault Enterprise namespace                      |
+| `verify`                  | `true`         | TLS verify: `true`/`false` or a CA-bundle path  |
+| `cache_ttl_seconds`       | `300`          | Disk+memory cache TTL; `0` disables caching     |
+| `request_timeout_seconds` | `30`           | Per-request Vault HTTP timeout                  |
+| `override_existing`       | `true`         | Vault values overwrite existing env values      |
+
+## How it behaves
+
+* **Never raises.** A misconfigured or unreachable Vault produces a clean
+  `FetchResult` with an `ErrorKind` (`not_configured`, `auth_failed`,
+  `ref_invalid`, `network`, `timeout`, ...), never a startup crash.
+* **Protects its own credentials.** The auth env vars (`VAULT_ADDR`,
+  `VAULT_TOKEN`, `VAULT_ROLE_ID`, `VAULT_SECRET_ID`) are marked protected, so a
+  secret stored in Vault cannot clobber the credential used to reach Vault.
+* **Caches values, never tokens.** The optional on-disk cache stores only the
+  resolved secret values; the token/secret_id are SHA-256 fingerprinted before
+  they touch the cache key.
+* **Skips non-env-safe keys.** A KV key that is not a valid environment
+  variable name is skipped with a warning rather than injected.
+
+## Threat model
+
+This plugin runs on the Hermes startup path with access to Vault credentials, so
+its security posture is deliberately narrow. Every protection below is already
+implemented; each maps to a concrete mechanism in the source.
+
+### Startup cannot be crashed by this source
+
+`fetch()` never raises. Every configuration problem returns a `FetchResult` with
+a machine-readable `ErrorKind` (`not_configured`, `auth_failed`, `ref_invalid`,
+`network`, `timeout`, `binary_missing`, `internal`), and the backend in
+`_client.py` only ever raises `RuntimeError`, which `fetch()` catches and
+classifies. A misconfigured, unreachable, or unauthenticated Vault degrades to a
+clean skip, never a traceback on the non-interactive startup path.
+
+### A Vault secret cannot hijack the credential used to reach Vault
+
+`protected_env_vars()` marks the auth env vars (`VAULT_ADDR`, `VAULT_TOKEN`,
+`VAULT_ROLE_ID`, `VAULT_SECRET_ID`, or their configured overrides) as protected.
+The orchestrator will not overwrite a protected variable, so a key that happens
+to be named `VAULT_TOKEN` inside the Vault payload cannot clobber the token the
+process is already using to authenticate. Names that are not valid env-var
+identifiers are dropped from the protected set, so a misconfigured section cannot
+silently weaken it.
+
+### Tokens never reach the on-disk cache in the clear
+
+The optional two-layer cache stores only resolved secret values. The Vault token
+(or the AppRole `role_id` and `secret_id`) is SHA-256 fingerprinted by
+`_fingerprint()` before it becomes part of the cache key, so neither the in-memory
+key nor the `vault_cache.json` file on disk contains the raw credential. Caching
+is opt-out: `cache_ttl_seconds: 0` disables it entirely.
+
+### Only environment-safe keys are injected
+
+Each KV v2 key is validated with the host's `is_valid_env_name()` before it is
+contributed. A key that is not a valid environment-variable name is skipped with
+a warning instead of being injected, so a stray Vault key cannot produce a
+malformed process environment.
+
+### TLS verification is on by default
+
+`verify` defaults to `true`. It is disabled only when the operator explicitly
+sets a false-y value, and a string value is treated as a CA-bundle path. TLS
+therefore fails closed rather than open.
+
+## Development
+
+Requires a `hermes-agent` source checkout (for the `agent.*` packages and the
+conformance kit at `tests/secret_sources/conformance.py`).
+
+```bash
+# host = hermes-agent checkout, plugin = this repo. Put the host on PYTHONPATH so
+# `import tests` resolves to the host conformance package. This repo keeps its own
+# tests in `checks/` (not `tests/`) precisely so it cannot shadow that package.
+PYTHONPATH="/path/to/hermes-agent:$(pwd)" pytest
+```
+
+`checks/test_conformance.py` runs the host `SecretSourceConformance` contract;
+`checks/test_vault_source.py` covers behavior with `hvac` mocked (no network, no
+Vault binary needed).
+
+To run against a real dev server:
+
+```bash
+vault server -dev            # prints VAULT_ADDR + a root token
+export VAULT_ADDR=http://127.0.0.1:8200
+export VAULT_TOKEN=<root-token-from-output>
+vault kv put secret/apps/my-agent API_KEY=abc DB_URL=postgres://x
+```
+
+## License
+
+MIT

hermes_vault_secret_source-0.1.0/README.md

@@ -0,0 +1,170 @@
+# hermes-vault-secret-source
+
+[![CI](https://github.com/cryptoyasenka/hermes-vault-secret-source/actions/workflows/ci.yml/badge.svg)](https://github.com/cryptoyasenka/hermes-vault-secret-source/actions/workflows/ci.yml)
+
+A [HashiCorp Vault](https://developer.hashicorp.com/vault) secret source for
+[Hermes Agent](https://github.com/NousResearch/hermes-agent), packaged as a
+standalone pip plugin.
+
+At Hermes startup it reads one Vault **KV v2** secret path and injects every
+key found there as an environment variable, the same way the bundled Bitwarden
+Secrets Manager source injects a whole project. This is a **bulk** source, so
+explicit per-variable bindings from mapped sources (like 1Password) take
+precedence over it.
+
+## Install
+
+```bash
+pip install "hermes-vault-secret-source @ git+https://github.com/cryptoyasenka/hermes-vault-secret-source"
+```
+
+The package is not on PyPI yet, so install it straight from the repository as
+shown above. Once it is published, this simplifies to:
+
+```bash
+pip install hermes-vault-secret-source
+```
+
+Either way this pulls in [`hvac`](https://hvac.readthedocs.io/), the official
+Python client for Vault. Install it into the same environment as `hermes-agent`.
+
+Hermes discovers the plugin automatically through the `hermes_agent.plugins`
+entry point, but plugins are opt-in. Enable it once:
+
+```bash
+hermes plugins enable hermes-hashicorp-vault
+```
+
+## Configure
+
+Add a `vault` block under `secrets` in your Hermes config:
+
+```yaml
+secrets:
+  vault:
+    enabled: true
+    # addr is read from $VAULT_ADDR by default; set `addr` to hard-code it.
+    path: apps/my-agent          # KV v2 path whose keys become env vars
+    mount_point: secret          # KV v2 mount (default: secret)
+    auth_method: token           # "token" (default) or "approle"
+    cache_ttl_seconds: 300       # 0 disables caching
+```
+
+Credentials are never written into config; they come from environment
+variables:
+
+| Auth method | Env vars used                                    |
+|-------------|--------------------------------------------------|
+| `token`     | `VAULT_ADDR`, `VAULT_TOKEN`                       |
+| `approle`   | `VAULT_ADDR`, `VAULT_ROLE_ID`, `VAULT_SECRET_ID` |
+
+The env-var names are overridable per field (`addr_env`, `token_env`,
+`role_id_env`, `secret_id_env`) if your deployment uses different names.
+
+### All config keys
+
+| Key                       | Default        | Meaning                                         |
+|---------------------------|----------------|-------------------------------------------------|
+| `enabled`                 | `false`        | Master switch                                   |
+| `addr`                    | `""`           | Vault URL; overrides `addr_env` when set        |
+| `addr_env`                | `VAULT_ADDR`   | Env var holding the Vault URL                   |
+| `path`                    | `""`           | KV v2 path to read (required)                   |
+| `mount_point`             | `secret`       | KV v2 secrets-engine mount                      |
+| `auth_method`             | `token`        | `token` or `approle`                            |
+| `token_env`               | `VAULT_TOKEN`  | Env var with the token (token auth)             |
+| `role_id_env`             | `VAULT_ROLE_ID`| Env var with the role_id (approle)              |
+| `secret_id_env`           | `VAULT_SECRET_ID` | Env var with the secret_id (approle)         |
+| `namespace`               | `""`           | Vault Enterprise namespace                      |
+| `verify`                  | `true`         | TLS verify: `true`/`false` or a CA-bundle path  |
+| `cache_ttl_seconds`       | `300`          | Disk+memory cache TTL; `0` disables caching     |
+| `request_timeout_seconds` | `30`           | Per-request Vault HTTP timeout                  |
+| `override_existing`       | `true`         | Vault values overwrite existing env values      |
+
+## How it behaves
+
+* **Never raises.** A misconfigured or unreachable Vault produces a clean
+  `FetchResult` with an `ErrorKind` (`not_configured`, `auth_failed`,
+  `ref_invalid`, `network`, `timeout`, ...), never a startup crash.
+* **Protects its own credentials.** The auth env vars (`VAULT_ADDR`,
+  `VAULT_TOKEN`, `VAULT_ROLE_ID`, `VAULT_SECRET_ID`) are marked protected, so a
+  secret stored in Vault cannot clobber the credential used to reach Vault.
+* **Caches values, never tokens.** The optional on-disk cache stores only the
+  resolved secret values; the token/secret_id are SHA-256 fingerprinted before
+  they touch the cache key.
+* **Skips non-env-safe keys.** A KV key that is not a valid environment
+  variable name is skipped with a warning rather than injected.
+
+## Threat model
+
+This plugin runs on the Hermes startup path with access to Vault credentials, so
+its security posture is deliberately narrow. Every protection below is already
+implemented; each maps to a concrete mechanism in the source.
+
+### Startup cannot be crashed by this source
+
+`fetch()` never raises. Every configuration problem returns a `FetchResult` with
+a machine-readable `ErrorKind` (`not_configured`, `auth_failed`, `ref_invalid`,
+`network`, `timeout`, `binary_missing`, `internal`), and the backend in
+`_client.py` only ever raises `RuntimeError`, which `fetch()` catches and
+classifies. A misconfigured, unreachable, or unauthenticated Vault degrades to a
+clean skip, never a traceback on the non-interactive startup path.
+
+### A Vault secret cannot hijack the credential used to reach Vault
+
+`protected_env_vars()` marks the auth env vars (`VAULT_ADDR`, `VAULT_TOKEN`,
+`VAULT_ROLE_ID`, `VAULT_SECRET_ID`, or their configured overrides) as protected.
+The orchestrator will not overwrite a protected variable, so a key that happens
+to be named `VAULT_TOKEN` inside the Vault payload cannot clobber the token the
+process is already using to authenticate. Names that are not valid env-var
+identifiers are dropped from the protected set, so a misconfigured section cannot
+silently weaken it.
+
+### Tokens never reach the on-disk cache in the clear
+
+The optional two-layer cache stores only resolved secret values. The Vault token
+(or the AppRole `role_id` and `secret_id`) is SHA-256 fingerprinted by
+`_fingerprint()` before it becomes part of the cache key, so neither the in-memory
+key nor the `vault_cache.json` file on disk contains the raw credential. Caching
+is opt-out: `cache_ttl_seconds: 0` disables it entirely.
+
+### Only environment-safe keys are injected
+
+Each KV v2 key is validated with the host's `is_valid_env_name()` before it is
+contributed. A key that is not a valid environment-variable name is skipped with
+a warning instead of being injected, so a stray Vault key cannot produce a
+malformed process environment.
+
+### TLS verification is on by default
+
+`verify` defaults to `true`. It is disabled only when the operator explicitly
+sets a false-y value, and a string value is treated as a CA-bundle path. TLS
+therefore fails closed rather than open.
+
+## Development
+
+Requires a `hermes-agent` source checkout (for the `agent.*` packages and the
+conformance kit at `tests/secret_sources/conformance.py`).
+
+```bash
+# host = hermes-agent checkout, plugin = this repo. Put the host on PYTHONPATH so
+# `import tests` resolves to the host conformance package. This repo keeps its own
+# tests in `checks/` (not `tests/`) precisely so it cannot shadow that package.
+PYTHONPATH="/path/to/hermes-agent:$(pwd)" pytest
+```
+
+`checks/test_conformance.py` runs the host `SecretSourceConformance` contract;
+`checks/test_vault_source.py` covers behavior with `hvac` mocked (no network, no
+Vault binary needed).
+
+To run against a real dev server:
+
+```bash
+vault server -dev            # prints VAULT_ADDR + a root token
+export VAULT_ADDR=http://127.0.0.1:8200
+export VAULT_TOKEN=<root-token-from-output>
+vault kv put secret/apps/my-agent API_KEY=abc DB_URL=postgres://x
+```
+
+## License
+
+MIT

hermes_vault_secret_source-0.1.0/hermes_vault_secret_source/__init__.py

@@ -0,0 +1,280 @@
+"""HashiCorp Vault as a Hermes Agent secret source.
+
+Bulk KV v2 source: reads one Vault KV v2 secret path and contributes its
+keys as environment variables at Hermes startup, mirroring how the bundled
+Bitwarden Secrets Manager source injects a whole project.
+
+Registered through the ``hermes_agent.plugins`` entry point (see
+pyproject.toml): Hermes' plugin loader imports this package and calls
+``register(ctx)``.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import FrozenSet
+
+from agent.secret_sources.base import (
+    ErrorKind,
+    FetchResult,
+    SecretSource,
+    is_valid_env_name,
+)
+
+from . import _client
+
+__all__ = ["VaultSource", "register"]
+
+# The following are NAMES of environment variables that hold Vault credentials,
+# not secret values themselves; bandit B105 flags the "TOKEN"/"SECRET" literals.
+_DEFAULT_ADDR_ENV = "VAULT_ADDR"
+_DEFAULT_TOKEN_ENV = "VAULT_TOKEN"  # nosec B105
+_DEFAULT_ROLE_ID_ENV = "VAULT_ROLE_ID"
+_DEFAULT_SECRET_ID_ENV = "VAULT_SECRET_ID"  # nosec B105
+_DEFAULT_MOUNT_POINT = "secret"
+_DEFAULT_CACHE_TTL_SECONDS = 300.0
+_DEFAULT_REQUEST_TIMEOUT_SECONDS = 30.0
+
+
+class VaultSource(SecretSource):
+    """HashiCorp Vault KV v2 as a registered secret source.
+
+    Thin adapter over :func:`_client.fetch_vault_secrets`. ``fetch()`` only
+    resolves values; precedence, override semantics, conflict warnings and
+    the actual ``os.environ`` writes belong to the orchestrator
+    (``agent.secret_sources.registry.apply_all``).
+
+    Vault is a **bulk** source: it injects every key found at the configured
+    KV v2 path, so explicit per-var bindings from mapped sources outrank it.
+    """
+
+    name = "vault"
+    label = "HashiCorp Vault"
+    shape = "bulk"
+    scheme = "vault"
+
+    def override_existing(self, cfg: dict) -> bool:
+        # Default True: the point of a central vault is rotation. If .env had
+        # the final say, rotating a key in Vault would not take effect until
+        # the stale .env line was also removed.
+        return bool(isinstance(cfg, dict) and cfg.get("override_existing", True))
+
+    def protected_env_vars(self, cfg: dict) -> FrozenSet[str]:
+        cfg = cfg if isinstance(cfg, dict) else {}
+        names = {
+            str(cfg.get("addr_env") or _DEFAULT_ADDR_ENV),
+            str(cfg.get("token_env") or _DEFAULT_TOKEN_ENV),
+            str(cfg.get("role_id_env") or _DEFAULT_ROLE_ID_ENV),
+            str(cfg.get("secret_id_env") or _DEFAULT_SECRET_ID_ENV),
+        }
+        # A vault that stores its own VAULT_TOKEN must never clobber the
+        # credential used to reach it. The orchestrator also requires valid
+        # env-var names, so drop anything a misconfigured section produced.
+        return frozenset(n for n in names if is_valid_env_name(n))
+
+    def config_schema(self) -> dict:
+        return {
+            "enabled": {"description": "Master switch", "default": False},
+            "addr": {
+                "description": "Vault server URL (overrides addr_env when set)",
+                "default": "",
+            },
+            "addr_env": {
+                "description": "Env var holding the Vault server URL",
+                "default": _DEFAULT_ADDR_ENV,
+            },
+            "path": {
+                "description": "KV v2 secret path whose keys become env vars",
+                "default": "",
+            },
+            "mount_point": {
+                "description": "KV v2 secrets-engine mount point",
+                "default": _DEFAULT_MOUNT_POINT,
+            },
+            "auth_method": {
+                "description": "How to authenticate: 'token' or 'approle'",
+                "default": "token",
+            },
+            "token_env": {
+                "description": "Env var holding the Vault token (auth_method=token)",
+                "default": _DEFAULT_TOKEN_ENV,
+            },
+            "role_id_env": {
+                "description": "Env var holding the AppRole role_id (auth_method=approle)",
+                "default": _DEFAULT_ROLE_ID_ENV,
+            },
+            "secret_id_env": {
+                "description": "Env var holding the AppRole secret_id (auth_method=approle)",
+                "default": _DEFAULT_SECRET_ID_ENV,
+            },
+            "namespace": {
+                "description": "Vault Enterprise namespace (empty for OSS)",
+                "default": "",
+            },
+            "verify": {
+                "description": "TLS verify: true/false or a CA-bundle path",
+                "default": True,
+            },
+            "cache_ttl_seconds": {
+                "description": "Disk+memory cache TTL; 0 disables caching",
+                "default": 300,
+            },
+            "request_timeout_seconds": {
+                "description": "Per-request Vault HTTP timeout in seconds",
+                "default": 30,
+            },
+            "override_existing": {
+                "description": "Vault values overwrite .env/shell values",
+                "default": True,
+            },
+        }
+
+    def fetch(self, cfg: dict, home_path: Path) -> FetchResult:
+        cfg = cfg if isinstance(cfg, dict) else {}
+        result = FetchResult()
+
+        addr_env = str(cfg.get("addr_env") or _DEFAULT_ADDR_ENV)
+        addr = str(cfg.get("addr") or os.environ.get(addr_env, "") or "").strip()
+        if not addr:
+            result.error = (
+                "secrets.vault is enabled but no Vault address is set "
+                f"(set {addr_env} or secrets.vault.addr)."
+            )
+            result.error_kind = ErrorKind.NOT_CONFIGURED
+            return result
+
+        path = str(cfg.get("path") or "").strip()
+        if not path:
+            result.error = (
+                "secrets.vault.path is empty (the KV v2 path whose keys are "
+                "injected as environment variables)."
+            )
+            result.error_kind = ErrorKind.NOT_CONFIGURED
+            return result
+
+        auth_method = str(cfg.get("auth_method") or "token").strip().lower()
+        # Empty-string initialisation, not a hardcoded secret (bandit B105).
+        token = role_id = secret_id = ""  # nosec B105
+        if auth_method == "token":
+            token_env = str(cfg.get("token_env") or _DEFAULT_TOKEN_ENV)
+            token = os.environ.get(token_env, "").strip()
+            if not token:
+                result.error = (
+                    f"secrets.vault auth_method is 'token' but {token_env} is not set."
+                )
+                result.error_kind = ErrorKind.NOT_CONFIGURED
+                return result
+        elif auth_method == "approle":
+            role_id_env = str(cfg.get("role_id_env") or _DEFAULT_ROLE_ID_ENV)
+            secret_id_env = str(cfg.get("secret_id_env") or _DEFAULT_SECRET_ID_ENV)
+            role_id = os.environ.get(role_id_env, "").strip()
+            secret_id = os.environ.get(secret_id_env, "").strip()
+            if not role_id or not secret_id:
+                result.error = (
+                    "secrets.vault auth_method is 'approle' but "
+                    f"{role_id_env} and {secret_id_env} are not both set."
+                )
+                result.error_kind = ErrorKind.NOT_CONFIGURED
+                return result
+        else:
+            result.error = (
+                f"secrets.vault.auth_method {auth_method!r} is not supported "
+                "(use 'token' or 'approle')."
+            )
+            result.error_kind = ErrorKind.NOT_CONFIGURED
+            return result
+
+        mount_point = (
+            str(cfg.get("mount_point") or _DEFAULT_MOUNT_POINT).strip()
+            or _DEFAULT_MOUNT_POINT
+        )
+        namespace = str(cfg.get("namespace") or "").strip() or None
+        verify = _coerce_verify(cfg.get("verify", True))
+        ttl = _coerce_float(
+            cfg.get("cache_ttl_seconds", _DEFAULT_CACHE_TTL_SECONDS),
+            _DEFAULT_CACHE_TTL_SECONDS,
+            allow_zero=True,
+        )
+        timeout = _coerce_float(
+            cfg.get("request_timeout_seconds", _DEFAULT_REQUEST_TIMEOUT_SECONDS),
+            _DEFAULT_REQUEST_TIMEOUT_SECONDS,
+            allow_zero=False,
+        )
+
+        try:
+            secrets, warnings = _client.fetch_vault_secrets(
+                addr=addr,
+                path=path,
+                mount_point=mount_point,
+                namespace=namespace,
+                verify=verify,
+                timeout=timeout,
+                auth_method=auth_method,
+                token=token,
+                role_id=role_id,
+                secret_id=secret_id,
+                cache_ttl_seconds=ttl,
+                home_path=home_path,
+            )
+        except RuntimeError as exc:
+            result.error = str(exc)
+            result.error_kind = _classify_vault_error(str(exc))
+            return result
+
+        result.secrets = secrets
+        result.warnings.extend(warnings)
+        return result
+
+
+def _coerce_float(value, default: float, *, allow_zero: bool) -> float:
+    try:
+        out = float(value)
+    except (TypeError, ValueError):
+        return default
+    if out < 0 or (out == 0 and not allow_zero):
+        return default
+    return out
+
+
+def _coerce_verify(value):
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        low = value.strip().lower()
+        if low in ("false", "0", "no", "off"):
+            return False
+        if low in ("true", "1", "yes", "on"):
+            return True
+        return value.strip()  # otherwise treat it as a CA-bundle path
+    return True
+
+
+def _classify_vault_error(message: str) -> ErrorKind:
+    """Best-effort mapping of a backend failure onto the shared taxonomy."""
+    lowered = message.lower()
+    if "not installed" in lowered:
+        return ErrorKind.BINARY_MISSING
+    if "timed out" in lowered or "timeout" in lowered:
+        return ErrorKind.TIMEOUT
+    if any(tok in lowered for tok in (
+        "forbidden", "permission denied", "invalid request",
+        "credentials rejected", "401", "403",
+    )):
+        return ErrorKind.AUTH_FAILED
+    if any(tok in lowered for tok in ("invalidpath", "not found", "404")):
+        return ErrorKind.REF_INVALID
+    if any(tok in lowered for tok in (
+        "connection", "network", "refused", "unreachable",
+        "resolve", "dns", "failed to create",
+    )):
+        return ErrorKind.NETWORK
+    return ErrorKind.INTERNAL
+
+
+def register(ctx) -> None:
+    """Entry point invoked by Hermes' plugin loader.
+
+    ``ctx`` is the PluginContext; it validates the instance and hands it to
+    the secret-source registry.
+    """
+    ctx.register_secret_source(VaultSource())

hermes_vault_secret_source-0.1.0/hermes_vault_secret_source/_client.py

@@ -0,0 +1,211 @@
+"""HashiCorp Vault backend: fetch + two-layer cache (hvac, KV v2, bulk).
+
+Mirrors the security posture of the bundled Bitwarden/1Password sources:
+this module only *reads* secrets and raises ``RuntimeError`` on any failure.
+The :class:`~hermes_vault_secret_source.VaultSource` adapter turns that into
+a ``FetchResult`` so nothing ever escapes onto the Hermes startup path.
+
+``hvac`` is imported lazily inside :func:`_read_kv2` so that importing this
+module (and running the conformance suite) never requires the dependency;
+only an actually-configured fetch touches Vault.
+"""
+from __future__ import annotations
+
+import hashlib
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from agent.secret_sources.base import is_valid_env_name
+
+# The shared on-disk cache substrate is re-exported by the host for backends.
+# If a host ships without it we degrade to no caching rather than fail import.
+try:
+    from agent.secret_sources._cache import CachedFetch, DiskCache
+except Exception:  # pragma: no cover - only on an incompatible host
+    CachedFetch = None  # type: ignore[assignment,misc]
+    DiskCache = None  # type: ignore[assignment,misc]
+
+
+def _serialize_cache_key(key) -> str:
+    return "|".join(str(part) for part in key)
+
+
+_CACHE: Dict[tuple, "CachedFetch"] = {}
+_DISK_CACHE = (
+    DiskCache("vault_cache.json", key_serializer=_serialize_cache_key)
+    if DiskCache is not None
+    else None
+)
+
+
+def _fingerprint(value: str) -> str:
+    """SHA-256 prefix of auth material, used only inside cache keys.
+
+    The on-disk cache stores secret *values*; the token/secret_id must never
+    reach it in the clear, so it is fingerprinted before it enters the key.
+    """
+    return hashlib.sha256((value or "").encode("utf-8")).hexdigest()[:16]
+
+
+def fetch_vault_secrets(
+    *,
+    addr: str,
+    path: str,
+    mount_point: str = "secret",
+    namespace: Optional[str] = None,
+    verify=True,
+    timeout: float = 30.0,
+    auth_method: str = "token",
+    token: str = "",
+    role_id: str = "",
+    secret_id: str = "",
+    cache_ttl_seconds: float = 300.0,
+    use_cache: bool = True,
+    home_path: Optional[Path] = None,
+) -> Tuple[Dict[str, str], List[str]]:
+    """Read one KV v2 path and return ``(env_name -> value, warnings)``.
+
+    Raises ``RuntimeError`` on any fatal condition (hvac missing, auth
+    failure, network error, bad path, unexpected shape). The caller in
+    ``__init__.py`` catches this and classifies it onto an ``ErrorKind``.
+    """
+    if auth_method == "approle":
+        auth_fp = _fingerprint("approle:" + role_id + ":" + secret_id)
+    else:
+        auth_fp = _fingerprint("token:" + token)
+    cache_key = (auth_fp, addr, mount_point, path, namespace or "")
+
+    if use_cache and CachedFetch is not None:
+        cached = _CACHE.get(cache_key)
+        if cached and cached.is_fresh(cache_ttl_seconds):
+            return dict(cached.secrets), []
+        if _DISK_CACHE is not None:
+            disk_cached = _DISK_CACHE.read(cache_key, cache_ttl_seconds, home_path)
+            if disk_cached is not None:
+                _CACHE[cache_key] = disk_cached
+                return dict(disk_cached.secrets), []
+
+    secrets, warnings = _read_kv2(
+        addr=addr,
+        path=path,
+        mount_point=mount_point,
+        namespace=namespace,
+        verify=verify,
+        timeout=timeout,
+        auth_method=auth_method,
+        token=token,
+        role_id=role_id,
+        secret_id=secret_id,
+    )
+
+    if use_cache and CachedFetch is not None:
+        entry = CachedFetch(secrets=secrets, fetched_at=time.time())
+        _CACHE[cache_key] = entry
+        if _DISK_CACHE is not None:
+            _DISK_CACHE.write(cache_key, entry, cache_ttl_seconds, home_path)
+    return secrets, warnings
+
+
+def _read_kv2(
+    *,
+    addr,
+    path,
+    mount_point,
+    namespace,
+    verify,
+    timeout,
+    auth_method,
+    token,
+    role_id,
+    secret_id,
+) -> Tuple[Dict[str, str], List[str]]:
+    try:
+        import hvac
+        from hvac import exceptions as hvac_exceptions
+    except ImportError as exc:
+        raise RuntimeError(
+            "hvac is not installed. Run `pip install hvac` in the Hermes "
+            "environment to use the Vault secret source."
+        ) from exc
+
+    try:
+        client = hvac.Client(
+            url=addr, verify=verify, timeout=timeout, namespace=namespace,
+        )
+    except Exception as exc:  # defensive: never let client init escape
+        raise RuntimeError(
+            _transport_message(f"failed to create Vault client for {addr}", exc)
+        ) from exc
+
+    # -- authenticate ---------------------------------------------------
+    try:
+        if auth_method == "approle":
+            client.auth.approle.login(role_id=role_id, secret_id=secret_id)
+        else:
+            client.token = token
+        authed = client.is_authenticated()
+    except hvac_exceptions.Forbidden as exc:
+        raise RuntimeError(f"Vault authentication forbidden: {exc}") from exc
+    except hvac_exceptions.InvalidRequest as exc:
+        raise RuntimeError(
+            f"Vault authentication failed (invalid request): {exc}"
+        ) from exc
+    except Exception as exc:
+        raise RuntimeError(_transport_message("Vault authentication", exc)) from exc
+    if not authed:
+        raise RuntimeError(
+            "Vault authentication failed: credentials rejected "
+            "(is_authenticated() returned False)."
+        )
+
+    # -- read the KV v2 path -------------------------------------------
+    try:
+        resp = client.secrets.kv.v2.read_secret_version(
+            path=path, mount_point=mount_point, raise_on_deleted_version=True,
+        )
+    except hvac_exceptions.InvalidPath as exc:
+        raise RuntimeError(
+            f"Vault path not found (invalidpath): {mount_point}/{path}: {exc}"
+        ) from exc
+    except hvac_exceptions.Forbidden as exc:
+        raise RuntimeError(
+            f"Vault read forbidden for {mount_point}/{path}: {exc}"
+        ) from exc
+    except Exception as exc:
+        raise RuntimeError(
+            _transport_message(f"Vault read for {mount_point}/{path}", exc)
+        ) from exc
+
+    data = None
+    if isinstance(resp, dict):
+        inner = resp.get("data")
+        if isinstance(inner, dict):
+            data = inner.get("data")
+    if not isinstance(data, dict):
+        raise RuntimeError(
+            "Vault returned an unexpected response shape (data.data missing)."
+        )
+
+    secrets: Dict[str, str] = {}
+    warnings: List[str] = []
+    for key, value in data.items():
+        if not isinstance(key, str) or value is None:
+            continue
+        str_value = value if isinstance(value, str) else str(value)
+        if not is_valid_env_name(key):
+            warnings.append(f"Skipping secret {key!r}: not a valid env-var name")
+            continue
+        secrets[key] = str_value
+    return secrets, warnings
+
+
+def _transport_message(context: str, exc: Exception) -> str:
+    """Build a RuntimeError message that ``_classify_vault_error`` can bucket."""
+    name = type(exc).__name__.lower()
+    text = str(exc).lower()
+    if "timeout" in name or "timed out" in text:
+        return f"{context} timed out: {exc}"
+    if "connection" in name or "connection" in text or "refused" in text:
+        return f"{context} connection error: {exc}"
+    return f"{context} failed: {exc}"

hermes_vault_secret_source-0.1.0/hermes_vault_secret_source.egg-info/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: hermes-vault-secret-source
+Version: 0.1.0
+Summary: HashiCorp Vault secret source for Hermes Agent (bulk KV v2).
+Author: cryptoyasenka
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cryptoyasenka/hermes-vault-secret-source
+Project-URL: Repository, https://github.com/cryptoyasenka/hermes-vault-secret-source
+Project-URL: Issues, https://github.com/cryptoyasenka/hermes-vault-secret-source/issues
+Keywords: hermes,hermes-agent,vault,hashicorp,secrets,plugin
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: hvac>=2.0
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# hermes-vault-secret-source
+
+[![CI](https://github.com/cryptoyasenka/hermes-vault-secret-source/actions/workflows/ci.yml/badge.svg)](https://github.com/cryptoyasenka/hermes-vault-secret-source/actions/workflows/ci.yml)
+
+A [HashiCorp Vault](https://developer.hashicorp.com/vault) secret source for
+[Hermes Agent](https://github.com/NousResearch/hermes-agent), packaged as a
+standalone pip plugin.
+
+At Hermes startup it reads one Vault **KV v2** secret path and injects every
+key found there as an environment variable, the same way the bundled Bitwarden
+Secrets Manager source injects a whole project. This is a **bulk** source, so
+explicit per-variable bindings from mapped sources (like 1Password) take
+precedence over it.
+
+## Install
+
+```bash
+pip install "hermes-vault-secret-source @ git+https://github.com/cryptoyasenka/hermes-vault-secret-source"
+```
+
+The package is not on PyPI yet, so install it straight from the repository as
+shown above. Once it is published, this simplifies to:
+
+```bash
+pip install hermes-vault-secret-source
+```
+
+Either way this pulls in [`hvac`](https://hvac.readthedocs.io/), the official
+Python client for Vault. Install it into the same environment as `hermes-agent`.
+
+Hermes discovers the plugin automatically through the `hermes_agent.plugins`
+entry point, but plugins are opt-in. Enable it once:
+
+```bash
+hermes plugins enable hermes-hashicorp-vault
+```
+
+## Configure
+
+Add a `vault` block under `secrets` in your Hermes config:
+
+```yaml
+secrets:
+  vault:
+    enabled: true
+    # addr is read from $VAULT_ADDR by default; set `addr` to hard-code it.
+    path: apps/my-agent          # KV v2 path whose keys become env vars
+    mount_point: secret          # KV v2 mount (default: secret)
+    auth_method: token           # "token" (default) or "approle"
+    cache_ttl_seconds: 300       # 0 disables caching
+```
+
+Credentials are never written into config; they come from environment
+variables:
+
+| Auth method | Env vars used                                    |
+|-------------|--------------------------------------------------|
+| `token`     | `VAULT_ADDR`, `VAULT_TOKEN`                       |
+| `approle`   | `VAULT_ADDR`, `VAULT_ROLE_ID`, `VAULT_SECRET_ID` |
+
+The env-var names are overridable per field (`addr_env`, `token_env`,
+`role_id_env`, `secret_id_env`) if your deployment uses different names.
+
+### All config keys
+
+| Key                       | Default        | Meaning                                         |
+|---------------------------|----------------|-------------------------------------------------|
+| `enabled`                 | `false`        | Master switch                                   |
+| `addr`                    | `""`           | Vault URL; overrides `addr_env` when set        |
+| `addr_env`                | `VAULT_ADDR`   | Env var holding the Vault URL                   |
+| `path`                    | `""`           | KV v2 path to read (required)                   |
+| `mount_point`             | `secret`       | KV v2 secrets-engine mount                      |
+| `auth_method`             | `token`        | `token` or `approle`                            |
+| `token_env`               | `VAULT_TOKEN`  | Env var with the token (token auth)             |
+| `role_id_env`             | `VAULT_ROLE_ID`| Env var with the role_id (approle)              |
+| `secret_id_env`           | `VAULT_SECRET_ID` | Env var with the secret_id (approle)         |
+| `namespace`               | `""`           | Vault Enterprise namespace                      |
+| `verify`                  | `true`         | TLS verify: `true`/`false` or a CA-bundle path  |
+| `cache_ttl_seconds`       | `300`          | Disk+memory cache TTL; `0` disables caching     |
+| `request_timeout_seconds` | `30`           | Per-request Vault HTTP timeout                  |
+| `override_existing`       | `true`         | Vault values overwrite existing env values      |
+
+## How it behaves
+
+* **Never raises.** A misconfigured or unreachable Vault produces a clean
+  `FetchResult` with an `ErrorKind` (`not_configured`, `auth_failed`,
+  `ref_invalid`, `network`, `timeout`, ...), never a startup crash.
+* **Protects its own credentials.** The auth env vars (`VAULT_ADDR`,
+  `VAULT_TOKEN`, `VAULT_ROLE_ID`, `VAULT_SECRET_ID`) are marked protected, so a
+  secret stored in Vault cannot clobber the credential used to reach Vault.
+* **Caches values, never tokens.** The optional on-disk cache stores only the
+  resolved secret values; the token/secret_id are SHA-256 fingerprinted before
+  they touch the cache key.
+* **Skips non-env-safe keys.** A KV key that is not a valid environment
+  variable name is skipped with a warning rather than injected.
+
+## Threat model
+
+This plugin runs on the Hermes startup path with access to Vault credentials, so
+its security posture is deliberately narrow. Every protection below is already
+implemented; each maps to a concrete mechanism in the source.
+
+### Startup cannot be crashed by this source
+
+`fetch()` never raises. Every configuration problem returns a `FetchResult` with
+a machine-readable `ErrorKind` (`not_configured`, `auth_failed`, `ref_invalid`,
+`network`, `timeout`, `binary_missing`, `internal`), and the backend in
+`_client.py` only ever raises `RuntimeError`, which `fetch()` catches and
+classifies. A misconfigured, unreachable, or unauthenticated Vault degrades to a
+clean skip, never a traceback on the non-interactive startup path.
+
+### A Vault secret cannot hijack the credential used to reach Vault
+
+`protected_env_vars()` marks the auth env vars (`VAULT_ADDR`, `VAULT_TOKEN`,
+`VAULT_ROLE_ID`, `VAULT_SECRET_ID`, or their configured overrides) as protected.
+The orchestrator will not overwrite a protected variable, so a key that happens
+to be named `VAULT_TOKEN` inside the Vault payload cannot clobber the token the
+process is already using to authenticate. Names that are not valid env-var
+identifiers are dropped from the protected set, so a misconfigured section cannot
+silently weaken it.
+
+### Tokens never reach the on-disk cache in the clear
+
+The optional two-layer cache stores only resolved secret values. The Vault token
+(or the AppRole `role_id` and `secret_id`) is SHA-256 fingerprinted by
+`_fingerprint()` before it becomes part of the cache key, so neither the in-memory
+key nor the `vault_cache.json` file on disk contains the raw credential. Caching
+is opt-out: `cache_ttl_seconds: 0` disables it entirely.
+
+### Only environment-safe keys are injected
+
+Each KV v2 key is validated with the host's `is_valid_env_name()` before it is
+contributed. A key that is not a valid environment-variable name is skipped with
+a warning instead of being injected, so a stray Vault key cannot produce a
+malformed process environment.
+
+### TLS verification is on by default
+
+`verify` defaults to `true`. It is disabled only when the operator explicitly
+sets a false-y value, and a string value is treated as a CA-bundle path. TLS
+therefore fails closed rather than open.
+
+## Development
+
+Requires a `hermes-agent` source checkout (for the `agent.*` packages and the
+conformance kit at `tests/secret_sources/conformance.py`).
+
+```bash
+# host = hermes-agent checkout, plugin = this repo. Put the host on PYTHONPATH so
+# `import tests` resolves to the host conformance package. This repo keeps its own
+# tests in `checks/` (not `tests/`) precisely so it cannot shadow that package.
+PYTHONPATH="/path/to/hermes-agent:$(pwd)" pytest
+```
+
+`checks/test_conformance.py` runs the host `SecretSourceConformance` contract;
+`checks/test_vault_source.py` covers behavior with `hvac` mocked (no network, no
+Vault binary needed).
+
+To run against a real dev server:
+
+```bash
+vault server -dev            # prints VAULT_ADDR + a root token
+export VAULT_ADDR=http://127.0.0.1:8200
+export VAULT_TOKEN=<root-token-from-output>
+vault kv put secret/apps/my-agent API_KEY=abc DB_URL=postgres://x
+```
+
+## License
+
+MIT

hermes_vault_secret_source-0.1.0/hermes_vault_secret_source.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+hermes_vault_secret_source/__init__.py
+hermes_vault_secret_source/_client.py
+hermes_vault_secret_source.egg-info/PKG-INFO
+hermes_vault_secret_source.egg-info/SOURCES.txt
+hermes_vault_secret_source.egg-info/dependency_links.txt
+hermes_vault_secret_source.egg-info/entry_points.txt
+hermes_vault_secret_source.egg-info/requires.txt
+hermes_vault_secret_source.egg-info/top_level.txt

hermes_vault_secret_source-0.1.0/hermes_vault_secret_source.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hermes_vault_secret_source-0.1.0/hermes_vault_secret_source.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[hermes_agent.plugins]
+hermes-hashicorp-vault = hermes_vault_secret_source

hermes_vault_secret_source-0.1.0/hermes_vault_secret_source.egg-info/requires.txt

@@ -0,0 +1,4 @@
+hvac>=2.0
+
+[test]
+pytest>=7

hermes_vault_secret_source-0.1.0/hermes_vault_secret_source.egg-info/top_level.txt

@@ -0,0 +1 @@
+hermes_vault_secret_source

hermes_vault_secret_source-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hermes-vault-secret-source"
+version = "0.1.0"
+description = "HashiCorp Vault secret source for Hermes Agent (bulk KV v2)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "cryptoyasenka" }]
+keywords = ["hermes", "hermes-agent", "vault", "hashicorp", "secrets", "plugin"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Operating System :: OS Independent",
+]
+dependencies = ["hvac>=2.0"]
+
+[project.optional-dependencies]
+test = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://github.com/cryptoyasenka/hermes-vault-secret-source"
+Repository = "https://github.com/cryptoyasenka/hermes-vault-secret-source"
+Issues = "https://github.com/cryptoyasenka/hermes-vault-secret-source/issues"
+
+# Hermes' plugin loader discovers standalone plugins through this entry-point
+# group. The value points at the package module that exposes `register(ctx)`
+# (loader does `getattr(module, "register")`), so it must be the module, not
+# `module:register`.
+[project.entry-points."hermes_agent.plugins"]
+hermes-hashicorp-vault = "hermes_vault_secret_source"
+
+[tool.setuptools]
+packages = ["hermes_vault_secret_source"]
+
+[tool.pytest.ini_options]
+# importlib mode keeps this repo's `tests/` from shadowing the hermes-agent
+# `tests` package (needed for tests.secret_sources.conformance).
+addopts = "--import-mode=importlib"
+
+[tool.mypy]
+files = ["hermes_vault_secret_source"]
+warn_redundant_casts = true
+no_implicit_optional = true
+
+# The host Hermes packages (agent.*) are resolved from a hermes-agent checkout on
+# PYTHONPATH at runtime and in CI, and hvac ships no type stubs. Treat both as
+# untyped external dependencies instead of type-checking their internals here.
+[[tool.mypy.overrides]]
+module = ["agent.*", "hvac", "hvac.*"]
+ignore_missing_imports = true
+follow_imports = "silent"

hermes_vault_secret_source-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+