agentvalet 0.2.0__tar.gz → 0.2.2__tar.gz

{agentvalet-0.2.0 → agentvalet-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentvalet
-Version: 0.2.0
+Version: 0.2.2
 Summary: Call approved SaaS platforms from any Python agent. Your agent never holds the downstream credential.
 Project-URL: Homepage, https://agentvalet.ai
 Project-URL: Documentation, https://docs.agentvalet.ai
@@ -95,8 +95,13 @@ the call stays outside it.
 
 `from_env()` reads `AGENTVALET_AGENT_ID` / `AGENTVALET_OWNER_ID` (or the bare
 `AGENT_ID` / `OWNER_ID`) and finds the key via `AGENT_PRIVATE_KEY_B64`,
-`AGENT_PRIVATE_KEY_PATH`, `AGENT_PRIVATE_KEY`, or `~/.agentvalet/agent.key`. To
-wire it explicitly:
+`AGENT_PRIVATE_KEY_PATH` (alias `AGENTVALET_PRIVATE_KEY_PATH`),
+`AGENT_PRIVATE_KEY`, or `~/.agentvalet/agent.key`. Env vars always win. When no
+agent id is set in the environment it falls back, in order, to `./.env.agentvalet`,
+`~/.agentvalet/config.json` (what `agentvalet register` writes) and
+`~/.agentvalet/agent.json`, taking the agent id, owner id, proxy URL and key path
+from the same file. An agent saved under a label (`~/.agentvalet/<label>/`) is
+never picked automatically: set the env vars for it. To wire it explicitly:
 
 ```python
 av = AgentValet(

{agentvalet-0.2.0 → agentvalet-0.2.2}/README.md

@@ -63,8 +63,13 @@ the call stays outside it.
 
 `from_env()` reads `AGENTVALET_AGENT_ID` / `AGENTVALET_OWNER_ID` (or the bare
 `AGENT_ID` / `OWNER_ID`) and finds the key via `AGENT_PRIVATE_KEY_B64`,
-`AGENT_PRIVATE_KEY_PATH`, `AGENT_PRIVATE_KEY`, or `~/.agentvalet/agent.key`. To
-wire it explicitly:
+`AGENT_PRIVATE_KEY_PATH` (alias `AGENTVALET_PRIVATE_KEY_PATH`),
+`AGENT_PRIVATE_KEY`, or `~/.agentvalet/agent.key`. Env vars always win. When no
+agent id is set in the environment it falls back, in order, to `./.env.agentvalet`,
+`~/.agentvalet/config.json` (what `agentvalet register` writes) and
+`~/.agentvalet/agent.json`, taking the agent id, owner id, proxy URL and key path
+from the same file. An agent saved under a label (`~/.agentvalet/<label>/`) is
+never picked automatically: set the env vars for it. To wire it explicitly:
 
 ```python
 av = AgentValet(

{agentvalet-0.2.0 → agentvalet-0.2.2}/examples/README.md

@@ -9,8 +9,9 @@ agentvalet register --code <invite-or-enrollment-code>
 ```
 
 `register` generates an RSA keypair **on your machine** — only the public half
-is sent — and writes `~/.agentvalet/agent.key`. After that `AgentValet.from_env()`
-works with no arguments.
+is sent — and writes `~/.agentvalet/agent.key` plus `~/.agentvalet/config.json`.
+After that `AgentValet.from_env()` works with no arguments, as long as no
+`AGENTVALET_AGENT_ID` / `AGENT_ID` env var points it at a different agent.
 
 | File | Use case |
 |---|---|

{agentvalet-0.2.0 → agentvalet-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentvalet"
-version = "0.2.0"
+version = "0.2.2"
 description = "Call approved SaaS platforms from any Python agent. Your agent never holds the downstream credential."
 readme = "README.md"
 requires-python = ">=3.9"

{agentvalet-0.2.0 → agentvalet-0.2.2}/src/agentvalet/__init__.py

@@ -37,7 +37,7 @@ from .errors import (
     UpstreamError,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 __all__ = [
     "DEFAULT_PROXY_URL",

{agentvalet-0.2.0 → agentvalet-0.2.2}/src/agentvalet/_protocol.py

@@ -8,6 +8,7 @@ other, it belongs in this module instead.
 
 from __future__ import annotations
 
+import base64
 import json
 import re
 from collections.abc import Mapping
@@ -223,3 +224,39 @@ def diagnose_network_error(err: BaseException, proxy_url: str) -> str:
 
 def _as_str(value: Any) -> str | None:
     return value if isinstance(value, str) else None
+
+
+def identity_from_bearer(token: str) -> dict[str, str]:
+    """Read the agent/owner id out of a bearer token's payload.
+
+    A child bearer token is a JWT carrying its own ``agent_id`` (and ``sub``,
+    and ``owner_id``). Without this the client has no idea who it is, which
+    breaks anything that has to name the subject — ``evaluate()`` sent an empty
+    ``subject.id`` and the proxy answered 400.
+
+    **This is not a security check.** The signature is not verified and must not
+    be trusted; the server is the sole authority on whether a token is valid.
+    This only recovers identifiers the caller would otherwise have to pass back
+    in by hand. Anything unparseable yields ``{}`` rather than raising: failing
+    locally would replace a clear 401 from the server with a confusing crash.
+    """
+    try:
+        parts = token.split(".")
+        if len(parts) != 3:
+            return {}
+        payload = parts[1]
+        payload += "=" * (-len(payload) % 4)
+        claims = json.loads(base64.urlsafe_b64decode(payload))
+        if not isinstance(claims, dict):
+            return {}
+    except Exception:
+        return {}
+
+    out: dict[str, str] = {}
+    agent_id = claims.get("agent_id") or claims.get("av_agent_id") or claims.get("sub")
+    owner_id = claims.get("owner_id") or claims.get("av_owner_id")
+    if isinstance(agent_id, str) and agent_id:
+        out["agent_id"] = agent_id
+    if isinstance(owner_id, str) and owner_id:
+        out["owner_id"] = owner_id
+    return out

{agentvalet-0.2.0 → agentvalet-0.2.2}/src/agentvalet/aio.py

@@ -27,6 +27,7 @@ from ._protocol import (
     build_action_body,
     build_issue_child_body,
     diagnose_network_error,
+    identity_from_bearer,
     interpret_action_response,
     interpret_approval_status,
     interpret_issue_child_response,
@@ -35,13 +36,7 @@ from ._protocol import (
 )
 from ._signing import sign_jwt
 from .child import ChildIdentity
-from .env import (
-    agent_id_from_env,
-    owner_id_from_env,
-    private_key_from_env,
-    proxy_url_from_env,
-    session_id_from_env,
-)
+from .env import resolve_from_env
 from .errors import ApprovalTimeoutError, ConfigError, NetworkError, ProxyError
 
 __all__ = ["AsyncAgentValet"]
@@ -90,21 +85,7 @@ class AsyncAgentValet:
 
     @classmethod
     def from_env(cls, **overrides: Any) -> AsyncAgentValet:
-        agent_id = overrides.pop("agent_id", None) or agent_id_from_env()
-        owner_id = overrides.pop("owner_id", None) or owner_id_from_env()
-        if not agent_id or not owner_id:
-            raise ConfigError(
-                "AgentValet identity not found in the environment. Set AGENTVALET_AGENT_ID and "
-                "AGENTVALET_OWNER_ID (or AGENT_ID / OWNER_ID), or run `agentvalet register`."
-            )
-        return cls(
-            agent_id=agent_id,
-            owner_id=owner_id,
-            private_key=overrides.pop("private_key", None) or private_key_from_env(),
-            proxy_url=overrides.pop("proxy_url", None) or proxy_url_from_env(),
-            session_id=overrides.pop("session_id", None) or session_id_from_env(),
-            **overrides,
-        )
+        return cls(**resolve_from_env(overrides), **overrides)
 
     @classmethod
     def from_bearer(
@@ -118,6 +99,12 @@ class AsyncAgentValet:
         """See :meth:`agentvalet.client.AgentValet.from_bearer`."""
         if not bearer_token:
             raise ConfigError("bearer_token is required")
+        # The token already carries the child's own agent/owner id. Recover them
+        # so anything that has to name the subject works in bearer mode too;
+        # an explicit override always wins.
+        derived = identity_from_bearer(bearer_token)
+        for key, value in derived.items():
+            overrides.setdefault(key, value)
         return cls(
             bearer_token=bearer_token,
             proxy_url=proxy_url or DEFAULT_PROXY_URL,

{agentvalet-0.2.0 → agentvalet-0.2.2}/src/agentvalet/client.py

@@ -23,6 +23,7 @@ from ._protocol import (
     build_action_body,
     build_issue_child_body,
     diagnose_network_error,
+    identity_from_bearer,
     interpret_action_response,
     interpret_approval_status,
     interpret_issue_child_response,
@@ -31,13 +32,7 @@ from ._protocol import (
 )
 from ._signing import sign_jwt
 from .child import ChildIdentity
-from .env import (
-    agent_id_from_env,
-    owner_id_from_env,
-    private_key_from_env,
-    proxy_url_from_env,
-    session_id_from_env,
-)
+from .env import resolve_from_env
 from .errors import ApprovalTimeoutError, ConfigError, NetworkError, ProxyError
 
 __all__ = ["AgentValet"]
@@ -94,25 +89,13 @@ class AgentValet:
     def from_env(cls, **overrides: Any) -> AgentValet:
         """Build a client from the environment.
 
-        Works with no arguments on a machine that has run ``agentvalet
-        register`` (or ``npx @agentvalet/register``). See :mod:`agentvalet.env`
-        for the accepted variable names and key formats.
+        Env vars win. With no agent id in the environment, falls back to the
+        identity ``agentvalet register`` (or ``npx @agentvalet/register``) wrote
+        to ``~/.agentvalet/config.json`` (or ``./.env.agentvalet``), signing with
+        the key path recorded beside it. See :mod:`agentvalet.env` for the
+        accepted variable names, files and key formats.
         """
-        agent_id = overrides.pop("agent_id", None) or agent_id_from_env()
-        owner_id = overrides.pop("owner_id", None) or owner_id_from_env()
-        if not agent_id or not owner_id:
-            raise ConfigError(
-                "AgentValet identity not found in the environment. Set AGENTVALET_AGENT_ID and "
-                "AGENTVALET_OWNER_ID (or AGENT_ID / OWNER_ID), or run `agentvalet register`."
-            )
-        return cls(
-            agent_id=agent_id,
-            owner_id=owner_id,
-            private_key=overrides.pop("private_key", None) or private_key_from_env(),
-            proxy_url=overrides.pop("proxy_url", None) or proxy_url_from_env(),
-            session_id=overrides.pop("session_id", None) or session_id_from_env(),
-            **overrides,
-        )
+        return cls(**resolve_from_env(overrides), **overrides)
 
     @classmethod
     def from_bearer(
@@ -136,6 +119,12 @@ class AgentValet:
         """
         if not bearer_token:
             raise ConfigError("bearer_token is required")
+        # The token already carries the child's own agent/owner id. Recover them
+        # so anything that has to name the subject works in bearer mode too;
+        # an explicit override always wins.
+        derived = identity_from_bearer(bearer_token)
+        for key, value in derived.items():
+            overrides.setdefault(key, value)
         return cls(
             bearer_token=bearer_token,
             proxy_url=proxy_url or DEFAULT_PROXY_URL,

agentvalet-0.2.2/src/agentvalet/env.py

@@ -0,0 +1,264 @@
+"""Environment resolution for ``AgentValet.from_env()``.
+
+Ported from ``packages/client/src/env.ts``. Accepts BOTH naming conventions
+already in the wild: the bare names the Node CLI and MCPB write
+(``AGENT_ID``, ``OWNER_ID``, ``PROXY_URL``, ``AGENT_PRIVATE_KEY*``) and
+``AGENTVALET_``-prefixed aliases, which is what the docs tell people to set.
+
+Env vars always win. When no agent id is set in the environment,
+``from_env()`` falls back to the identity files the registration flows write
+(see :func:`identity_from_disk`), so a machine that has run
+``agentvalet register`` or ``npx @agentvalet/register`` works with no extra
+config. That is the single most important onboarding affordance in the package
+— do not "tidy" it away.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from ._constants import DEFAULT_PROXY_URL
+from .errors import ConfigError
+
+__all__ = [
+    "agent_id_from_env",
+    "identity_from_disk",
+    "owner_id_from_env",
+    "private_key_from_env",
+    "proxy_url_from_env",
+    "session_id_from_env",
+]
+
+#: Written by the register flow. Also read by the Node SDK and mcp-server.
+KEY_PATH = Path.home() / ".agentvalet" / "agent.key"
+
+
+def _read_env(name: str) -> str | None:
+    """Empty strings and unresolved MCPB placeholders count as not-set.
+
+    The MCPB writes a literal ``${user_config.foo}`` when a field is left
+    blank. Treating that as a real value produces a baffling 401 much later,
+    far from the actual mistake.
+    """
+    raw = os.environ.get(name)
+    if raw is None:
+        return None
+    value = raw.strip()
+    if not value:
+        return None
+    if value.startswith("${") and value.endswith("}"):
+        return None
+    return value
+
+
+def _read_either(suffix: str) -> str | None:
+    """``AGENTVALET_``-prefixed name wins over the bare name when both are set."""
+    return _read_env(f"AGENTVALET_{suffix}") or _read_env(suffix)
+
+
+def agent_id_from_env() -> str | None:
+    return _read_either("AGENT_ID")
+
+
+def owner_id_from_env() -> str | None:
+    return _read_either("OWNER_ID")
+
+
+def proxy_url_from_env(fallback: str | None = None) -> str:
+    """``AGENTVALET_API_URL`` (the name ``.env.agentvalet`` uses) is an alias.
+
+    ``fallback`` (e.g. from an identity file) applies only when no env var is set.
+    """
+    url = _read_either("PROXY_URL") or _read_env("AGENTVALET_API_URL") or fallback
+    return (url or DEFAULT_PROXY_URL).rstrip("/")
+
+
+def session_id_from_env() -> str | None:
+    return _read_either("SESSION_ID")
+
+
+def private_key_from_env(fallback_path: str | None = None) -> str:
+    """Resolve the RS256 private key PEM.
+
+    Precedence, matching the Node SDK exactly:
+
+    1. ``AGENT_PRIVATE_KEY_B64``  — base64-encoded PEM (12-factor / container safe)
+    2. ``AGENT_PRIVATE_KEY_PATH`` — path to a PEM file (``AGENTVALET_PRIVATE_KEY_PATH``,
+       the name ``.env.agentvalet`` uses, is an alias)
+    3. ``AGENT_PRIVATE_KEY``      — raw multi-line PEM, or ``\\n``-escaped single line
+    4. ``fallback_path``          — the key path recorded beside an on-disk identity
+    5. ``~/.agentvalet/agent.key`` — written by the register flow
+    """
+    b64 = _read_either("AGENT_PRIVATE_KEY_B64")
+    if b64:
+        return base64.b64decode(b64).decode("utf-8").strip()
+
+    path = _read_either("AGENT_PRIVATE_KEY_PATH") or _read_env("AGENTVALET_PRIVATE_KEY_PATH")
+    if path:
+        try:
+            return Path(path).read_text(encoding="utf-8").strip()
+        except OSError as err:
+            raise ConfigError(f"Cannot read AGENT_PRIVATE_KEY_PATH ({path}): {err}") from err
+
+    raw = _read_either("AGENT_PRIVATE_KEY")
+    if raw:
+        unescaped = raw.replace("\\n", "\n")
+        # Secrets UIs routinely trim the PEM armour on paste. Re-wrap rather
+        # than failing deep inside the crypto layer with an opaque message.
+        if not unescaped.startswith("-----"):
+            return f"-----BEGIN PRIVATE KEY-----\n{unescaped}\n-----END PRIVATE KEY-----"
+        return unescaped
+
+    if fallback_path:
+        # Paired with the on-disk agent id. Failing loudly beats silently signing
+        # with the default key, which may belong to a different agent.
+        try:
+            return Path(fallback_path).read_text(encoding="utf-8").strip()
+        except OSError as err:
+            raise ConfigError(
+                f"Cannot read the agent key at {fallback_path} (named by your AgentValet "
+                f"identity file): {err}"
+            ) from err
+
+    disk = _read_disk_key()
+    if disk:
+        return disk
+
+    raise ConfigError(
+        "No private key found. Set AGENT_PRIVATE_KEY, AGENT_PRIVATE_KEY_PATH, or "
+        "AGENT_PRIVATE_KEY_B64, or run `agentvalet register` to create an agent and "
+        "write ~/.agentvalet/agent.key."
+    )
+
+
+def _read_disk_key() -> str | None:
+    try:
+        return KEY_PATH.read_text(encoding="utf-8").strip() or None
+    except OSError:
+        return None
+
+
+def _str(value: Any) -> str | None:
+    return value.strip() if isinstance(value, str) and value.strip() else None
+
+
+def _read_json(path: Path) -> dict[str, Any] | None:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def _parse_dotenv(text: str) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        value = value.strip()
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in "\"'":
+            value = value[1:-1]
+        out[key.strip()] = value
+    return out
+
+
+def identity_from_disk(
+    cwd: Path | None = None, home: Path | None = None
+) -> dict[str, str | None] | None:
+    """The identity the registration flows leave on disk. First hit wins:
+
+    1. ``<cwd>/.env.agentvalet``     — written by ``npx @agentvalet/register`` (project-level)
+    2. ``~/.agentvalet/config.json`` — written by ``agentvalet register`` and the Node
+       CLI; the most recent registration
+    3. ``~/.agentvalet/agent.json``  — written by ``agentvalet-register claim`` (unlabelled)
+
+    Returns ``{"agent_id", "owner_id", "key_path", "proxy_url", "source"}`` or
+    ``None``. Each source yields an agent id together with the key path written
+    beside it, never mixed with another source's. Labelled agents
+    (``~/.agentvalet/<label>/``) are not guessed at: point the env vars at them.
+    """
+    cwd = cwd or Path.cwd()
+    av_dir = (home or Path.home()) / ".agentvalet"
+
+    env_file = cwd / ".env.agentvalet"
+    try:
+        env_vars = _parse_dotenv(env_file.read_text(encoding="utf-8"))
+    except OSError:
+        env_vars = {}
+    agent_id = _str(env_vars.get("AGENTVALET_AGENT_ID"))
+    if agent_id:
+        return {
+            "agent_id": agent_id,
+            "owner_id": _str(env_vars.get("AGENTVALET_OWNER_ID")),
+            "key_path": _str(env_vars.get("AGENTVALET_PRIVATE_KEY_PATH")),
+            "proxy_url": _str(env_vars.get("AGENTVALET_API_URL")),
+            "source": str(env_file),
+        }
+
+    config_file = av_dir / "config.json"
+    cfg = _read_json(config_file) or {}
+    # Every register flow rewrites lastAgentId/lastKeyPath as a pair; the Node
+    # ``onboard`` flow leaves agentId/keyPath stale, so the "last" pair wins.
+    last = _str(cfg.get("lastAgentId"))
+    agent_id = last or _str(cfg.get("agentId"))
+    if agent_id:
+        return {
+            "agent_id": agent_id,
+            "owner_id": _str(cfg.get("ownerId")),
+            "key_path": _str(cfg.get("lastKeyPath") if last else cfg.get("keyPath")),
+            "proxy_url": _str(cfg.get("apiUrl")) or _str(cfg.get("proxyUrl")),
+            "source": str(config_file),
+        }
+
+    agent_file = av_dir / "agent.json"
+    ident = _read_json(agent_file) or {}
+    agent_id = _str(ident.get("agent_id"))
+    if agent_id:
+        return {
+            "agent_id": agent_id,
+            "owner_id": _str(ident.get("owner_id")),
+            "key_path": str(av_dir / "agent.key"),
+            "proxy_url": _str(ident.get("proxy_url")),
+            "source": str(agent_file),
+        }
+
+    return None
+
+
+def resolve_from_env(overrides: dict[str, Any]) -> dict[str, Any]:
+    """Shared body of ``AgentValet.from_env`` / ``AsyncAgentValet.from_env``.
+
+    Pops the identity keys out of ``overrides`` and returns constructor kwargs.
+    Precedence per field: explicit override, then env vars, then the identity
+    file. The file is consulted only when no agent id is given, so an env agent
+    id is never paired with a file's key.
+    """
+    agent_id = overrides.pop("agent_id", None) or agent_id_from_env()
+    disk = None if agent_id else identity_from_disk()
+    if disk:
+        agent_id = disk["agent_id"]
+    owner_id = (
+        overrides.pop("owner_id", None) or owner_id_from_env() or (disk or {}).get("owner_id")
+    )
+    if not agent_id or not owner_id:
+        hint = f" ({disk['source']} names an agent but no owner id.)" if disk else ""
+        raise ConfigError(
+            "AgentValet identity not found. Set AGENTVALET_AGENT_ID and AGENTVALET_OWNER_ID "
+            "(or AGENT_ID / OWNER_ID), or run `agentvalet register` to write "
+            "~/.agentvalet/config.json." + hint
+        )
+    return {
+        "agent_id": agent_id,
+        "owner_id": owner_id,
+        "private_key": overrides.pop("private_key", None)
+        or private_key_from_env((disk or {}).get("key_path")),
+        "proxy_url": overrides.pop("proxy_url", None)
+        or proxy_url_from_env((disk or {}).get("proxy_url")),
+        "session_id": overrides.pop("session_id", None) or session_id_from_env(),
+    }

{agentvalet-0.2.0 → agentvalet-0.2.2}/src/agentvalet/register.py

@@ -173,7 +173,10 @@ def main(argv: list[str] | None = None) -> int:
         print(f"  owner:    {identity['ownerId']}")
         print(f"  proxy:    {identity['apiUrl']}")
         print(f"  key:      {AGENT_KEY_PATH}  (private key never left this machine)")
-        print("\nYou can now use AgentValet.from_env() with no further configuration.")
+        print(
+            f"\nSaved to {CONFIG_PATH}. AgentValet.from_env() reads it when "
+            "AGENTVALET_AGENT_ID is not set (env vars take precedence)."
+        )
         return 0
 
     return 1

{agentvalet-0.2.0 → agentvalet-0.2.2}/tests/conftest.py

@@ -19,6 +19,24 @@ from agentvalet import AgentValet, AsyncAgentValet
 PROXY = "https://api.example.test"
 
 
+@pytest.fixture(autouse=True)
+def isolated_disk(monkeypatch, tmp_path):
+    """Empty $HOME and cwd for every test.
+
+    ``from_env()`` falls back to ``~/.agentvalet/config.json`` and
+    ``./.env.agentvalet``; without this a developer machine that has run
+    ``agentvalet register`` would leak its real identity into the tests.
+    """
+    home = tmp_path / "home"
+    work = tmp_path / "work"
+    (home / ".agentvalet").mkdir(parents=True)
+    work.mkdir()
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setenv("USERPROFILE", str(home))
+    monkeypatch.chdir(work)
+    return home
+
+
 @pytest.fixture(scope="session")
 def private_key_pem() -> str:
     """One 2048-bit key for the whole session — keygen is slow."""

agentvalet-0.2.2/tests/test_bearer_identity.py

@@ -0,0 +1,63 @@
+"""Bearer-mode identity.
+
+Its own module because test_client.py sets a module-level asyncio mark and
+these are plain sync assertions about a classmethod — no event loop involved.
+Still parametrized over both implementations, for the reason conftest gives:
+agentvalet.aio must not silently drift from agentvalet.client.
+"""
+
+import base64 as _base64
+import json as _json
+
+import pytest
+
+from agentvalet import AgentValet, AsyncAgentValet, ChildIdentity
+
+BEARER_CLASSES = [AgentValet, AsyncAgentValet]
+
+
+def _jwt(payload: dict) -> str:
+    def seg(obj: dict) -> str:
+        return _base64.urlsafe_b64encode(_json.dumps(obj).encode()).rstrip(b"=").decode()
+
+    return f"{seg({'alg': 'RS256'})}.{seg(payload)}.not-a-real-signature"
+
+
+@pytest.mark.parametrize("cls", BEARER_CLASSES)
+def test_from_bearer_derives_identity_from_the_token(cls):
+    av = cls.from_bearer(_jwt({"agent_id": "agt_child123", "owner_id": "own_456", "sub": "agt_child123"}))
+    assert av.agent_id == "agt_child123"
+    assert av.owner_id == "own_456"
+
+
+@pytest.mark.parametrize("cls", BEARER_CLASSES)
+def test_from_bearer_prefers_an_explicit_override(cls):
+    av = cls.from_bearer(_jwt({"agent_id": "agt_from_token"}), agent_id="agt_explicit")
+    assert av.agent_id == "agt_explicit"
+
+
+@pytest.mark.parametrize("cls", BEARER_CLASSES)
+def test_from_bearer_falls_back_to_sub(cls):
+    assert cls.from_bearer(_jwt({"sub": "agt_from_sub"})).agent_id == "agt_from_sub"
+
+
+@pytest.mark.parametrize("cls", BEARER_CLASSES)
+def test_from_bearer_tolerates_a_token_it_cannot_parse(cls):
+    # A malformed token must not raise here. The server is the sole authority on
+    # token validity; failing locally would replace a clear 401 with a confusing
+    # client-side crash.
+    assert cls.from_bearer("not-a-jwt").agent_id == ""
+    assert cls.from_bearer(_jwt({"no": "identity"})).agent_id == ""
+
+
+@pytest.mark.parametrize("cls", BEARER_CLASSES)
+def test_child_identity_client_can_name_its_own_subject(cls):
+    """The path that actually broke: ChildIdentity.client() -> evaluate()."""
+    child = ChildIdentity(
+        child_agent_id="agt_child789",
+        bearer_token=_jwt({"agent_id": "agt_child789", "owner_id": "own_1"}),
+        expires_at="2099-01-01T00:00:00Z",
+        granted=[{"platform": "github", "scopes": ["github:repo.read"]}],
+    )
+    built = child.client() if cls is AgentValet else child.aio_client()
+    assert built.agent_id == "agt_child789", "an empty subject.id is what the proxy 400s on"

{agentvalet-0.2.0 → agentvalet-0.2.2}/tests/test_client.py

@@ -61,6 +61,59 @@ async def test_from_env_names_the_vars_when_identity_absent(make_client, monkeyp
         make_client.cls.from_env()
 
 
+IDENTITY_ENV = (
+    "AGENTVALET_AGENT_ID", "AGENT_ID", "AGENTVALET_OWNER_ID", "OWNER_ID",
+    "AGENTVALET_PROXY_URL", "PROXY_URL", "AGENTVALET_API_URL",
+    "AGENTVALET_AGENT_PRIVATE_KEY", "AGENT_PRIVATE_KEY",
+    "AGENTVALET_AGENT_PRIVATE_KEY_B64", "AGENT_PRIVATE_KEY_B64",
+    "AGENTVALET_AGENT_PRIVATE_KEY_PATH", "AGENT_PRIVATE_KEY_PATH", "AGENTVALET_PRIVATE_KEY_PATH",
+)
+
+
+async def test_from_env_works_after_register_with_no_env_vars(
+    make_client, monkeypatch, isolated_disk, private_key_pem
+):
+    """The promise `agentvalet register` prints: no env vars, just the files it wrote."""
+    import json
+
+    from agentvalet import register
+
+    for name in IDENTITY_ENV:
+        monkeypatch.delenv(name, raising=False)
+    av_dir = isolated_disk / ".agentvalet"
+    monkeypatch.setattr(register, "AGENT_DIR", av_dir)
+    monkeypatch.setattr(register, "AGENT_KEY_PATH", av_dir / "agent.key")
+    monkeypatch.setattr(register, "CONFIG_PATH", av_dir / "config.json")
+    register.save_identity(
+        {"agentId": "agt_disk", "ownerId": "own_disk", "apiUrl": "https://disk.test/"},
+        private_key_pem,
+    )
+    assert json.loads((av_dir / "config.json").read_text())["agentId"] == "agt_disk"
+
+    client = make_client.cls.from_env()
+    assert (client.agent_id, client.owner_id, client.proxy_url) == (
+        "agt_disk", "own_disk", "https://disk.test",
+    )
+
+
+async def test_from_env_never_pairs_an_env_agent_id_with_a_file(
+    make_client, monkeypatch, isolated_disk, private_key_pem
+):
+    import json
+
+    for name in IDENTITY_ENV:
+        monkeypatch.delenv(name, raising=False)
+    (isolated_disk / ".agentvalet" / "config.json").write_text(
+        json.dumps({"agentId": "agt_disk", "ownerId": "own_disk"}), encoding="utf-8"
+    )
+    monkeypatch.setenv("AGENT_ID", "agt_env")
+    with pytest.raises(ConfigError):
+        make_client.cls.from_env()  # file ignored entirely -> no owner id
+    monkeypatch.setenv("OWNER_ID", "own_env")
+    client = make_client.cls.from_env(private_key=private_key_pem)
+    assert (client.agent_id, client.owner_id) == ("agt_env", "own_env")
+
+
 async def test_rejects_out_of_charset_session_id(make_client):
     with pytest.raises(ConfigError, match="session_id"):
         make_client(session_id="not a valid id!")
@@ -572,3 +625,4 @@ async def test_child_identity_client_and_aio_client_build_bearer_clients():
     async_client = identity.aio_client()
     assert isinstance(async_client, AsyncAgentValet)
     assert async_client._bearer_token == "tok_child_abc"
+

agentvalet-0.2.2/tests/test_env.py

@@ -0,0 +1,192 @@
+"""Mirrors ``packages/client/tests/env.test.ts``."""
+
+import base64
+import json
+from pathlib import Path
+
+import pytest
+
+from agentvalet._constants import DEFAULT_PROXY_URL
+from agentvalet.env import (
+    agent_id_from_env,
+    identity_from_disk,
+    private_key_from_env,
+    proxy_url_from_env,
+    session_id_from_env,
+)
+from agentvalet.errors import ConfigError
+
+PEM = "-----BEGIN PRIVATE KEY-----\nAAAA\n-----END PRIVATE KEY-----"
+
+ALL_NAMES = [
+    "AGENTVALET_AGENT_ID", "AGENT_ID",
+    "AGENTVALET_OWNER_ID", "OWNER_ID",
+    "AGENTVALET_PROXY_URL", "PROXY_URL",
+    "AGENTVALET_AGENT_PRIVATE_KEY", "AGENT_PRIVATE_KEY",
+    "AGENTVALET_AGENT_PRIVATE_KEY_B64", "AGENT_PRIVATE_KEY_B64",
+    "AGENTVALET_AGENT_PRIVATE_KEY_PATH", "AGENT_PRIVATE_KEY_PATH",
+    "AGENTVALET_SESSION_ID", "SESSION_ID",
+    "AGENTVALET_PRIVATE_KEY_PATH", "AGENTVALET_API_URL",
+]
+
+
+@pytest.fixture
+def clean_env(monkeypatch):
+    """Blank every consulted name so a real env var can't leak into a test."""
+    for name in ALL_NAMES:
+        monkeypatch.delenv(name, raising=False)
+    return monkeypatch
+
+
+class TestIdentity:
+    def test_prefixed_name_wins_over_bare(self, clean_env):
+        clean_env.setenv("AGENT_ID", "agt_bare")
+        clean_env.setenv("AGENTVALET_AGENT_ID", "agt_prefixed")
+        assert agent_id_from_env() == "agt_prefixed"
+
+    def test_falls_back_to_the_bare_name_the_cli_writes(self, clean_env):
+        clean_env.setenv("AGENT_ID", "agt_bare")
+        assert agent_id_from_env() == "agt_bare"
+
+    def test_unresolved_mcpb_placeholder_counts_as_not_set(self, clean_env):
+        # The MCPB writes a literal "${user_config.x}" for a blank field.
+        # Accepting it produces a baffling 401 far from the real mistake.
+        clean_env.setenv("AGENT_ID", "${user_config.agent_id}")
+        assert agent_id_from_env() is None
+
+    def test_proxy_url_defaults_and_strips_trailing_slash(self, clean_env):
+        assert proxy_url_from_env() == DEFAULT_PROXY_URL
+        clean_env.setenv("PROXY_URL", "https://self.hosted.test/")
+        assert proxy_url_from_env() == "https://self.hosted.test"
+
+    def test_session_id_absent_by_default(self, clean_env):
+        assert session_id_from_env() is None
+
+    def test_session_id_prefixed_name_wins_over_bare(self, clean_env):
+        clean_env.setenv("SESSION_ID", "sess_bare")
+        clean_env.setenv("AGENTVALET_SESSION_ID", "sess_prefixed")
+        assert session_id_from_env() == "sess_prefixed"
+
+
+class TestPrivateKey:
+    def test_base64_takes_precedence(self, clean_env):
+        clean_env.setenv("AGENT_PRIVATE_KEY_B64", base64.b64encode(PEM.encode()).decode())
+        assert private_key_from_env() == PEM
+
+    def test_reads_a_pem_file_by_path(self, clean_env, tmp_path):
+        path = tmp_path / "agent.key"
+        path.write_text(PEM, encoding="utf-8")
+        clean_env.setenv("AGENT_PRIVATE_KEY_PATH", str(path))
+        assert private_key_from_env() == PEM
+
+    def test_unreadable_path_raises_config_error_naming_it(self, clean_env, tmp_path):
+        missing = tmp_path / "definitely-not-here.key"
+        clean_env.setenv("AGENT_PRIVATE_KEY_PATH", str(missing))
+        with pytest.raises(ConfigError, match="definitely-not-here"):
+            private_key_from_env()
+
+    def test_unescapes_a_collapsed_single_line_pem(self, clean_env):
+        clean_env.setenv(
+            "AGENT_PRIVATE_KEY",
+            "-----BEGIN PRIVATE KEY-----\\nAAAA\\n-----END PRIVATE KEY-----",
+        )
+        assert private_key_from_env() == PEM
+
+    def test_rewraps_a_blob_that_lost_its_pem_armour(self, clean_env):
+        # Secrets UIs routinely trim the delimiters on paste.
+        clean_env.setenv("AGENT_PRIVATE_KEY", "AAAA")
+        assert private_key_from_env() == PEM
+
+
+class TestDotEnvAgentvaletAliases:
+    """``.env.agentvalet`` (written by the Node CLI) uses these names."""
+
+    def test_reads_agentvalet_private_key_path(self, clean_env, tmp_path):
+        path = tmp_path / "agent.key"
+        path.write_text(PEM, encoding="utf-8")
+        clean_env.setenv("AGENTVALET_PRIVATE_KEY_PATH", str(path))
+        assert private_key_from_env() == PEM
+
+    def test_reads_agentvalet_api_url_but_proxy_url_wins(self, clean_env):
+        clean_env.setenv("AGENTVALET_API_URL", "https://api-url.test/")
+        assert proxy_url_from_env() == "https://api-url.test"
+        clean_env.setenv("PROXY_URL", "https://proxy-url.test")
+        assert proxy_url_from_env() == "https://proxy-url.test"
+
+    def test_identity_file_key_path_comes_after_every_env_source(self, clean_env, tmp_path):
+        path = tmp_path / "file.key"
+        path.write_text("FILE", encoding="utf-8")
+        assert private_key_from_env(str(path)) == "FILE"
+        clean_env.setenv("AGENT_PRIVATE_KEY", PEM)
+        assert private_key_from_env(str(path)) == PEM
+
+    def test_missing_paired_key_fails_loudly(self, clean_env, tmp_path):
+        with pytest.raises(ConfigError, match="no-such-av-key"):
+            private_key_from_env(str(tmp_path / "no-such-av-key.key"))
+
+
+class TestIdentityFromDisk:
+    @pytest.fixture
+    def dirs(self, tmp_path):
+        cwd, home = tmp_path / "proj", tmp_path / "h"
+        cwd.mkdir()
+        (home / ".agentvalet").mkdir(parents=True)
+        return cwd, home, home / ".agentvalet"
+
+    def test_none_when_nothing_registered(self, dirs):
+        cwd, home, _ = dirs
+        assert identity_from_disk(cwd, home) is None
+
+    def test_reads_env_agentvalet_written_by_node_cli(self, dirs):
+        cwd, home, _ = dirs
+        (cwd / ".env.agentvalet").write_text(
+            "# AgentValet — generated by agentvalet-register\r\n"
+            "AGENTVALET_AGENT_ID=agt_proj\r\n"
+            "AGENTVALET_OWNER_ID=own_proj\r\n"
+            "AGENTVALET_API_URL=https://self.hosted.test\r\n"
+            "AGENTVALET_PRIVATE_KEY_PATH=/keys/proj.key\r\n",
+            encoding="utf-8",
+        )
+        ident = identity_from_disk(cwd, home)
+        assert ident is not None
+        assert (ident["agent_id"], ident["owner_id"], ident["key_path"], ident["proxy_url"]) == (
+            "agt_proj", "own_proj", "/keys/proj.key", "https://self.hosted.test",
+        )
+
+    def test_project_file_beats_machine_config(self, dirs):
+        cwd, home, av = dirs
+        (cwd / ".env.agentvalet").write_text("AGENTVALET_AGENT_ID=agt_proj\n", encoding="utf-8")
+        (av / "config.json").write_text(json.dumps({"agentId": "agt_machine"}), encoding="utf-8")
+        assert identity_from_disk(cwd, home)["agent_id"] == "agt_proj"
+
+    def test_last_pair_wins_over_stale_agent_id(self, dirs):
+        # Node `onboard` updates only lastAgentId/lastKeyPath. Mixing the pairs
+        # would sign one agent's id with another agent's key.
+        cwd, home, av = dirs
+        (av / "config.json").write_text(json.dumps({
+            "agentId": "agt_old", "keyPath": "/old.key", "ownerId": "own_x",
+            "lastAgentId": "agt_new", "lastKeyPath": "/new.key", "proxyUrl": "https://p.test",
+        }), encoding="utf-8")
+        ident = identity_from_disk(cwd, home)
+        assert (ident["agent_id"], ident["key_path"], ident["proxy_url"]) == (
+            "agt_new", "/new.key", "https://p.test",
+        )
+
+    def test_account_only_config_is_not_an_identity(self, dirs):
+        cwd, home, av = dirs
+        (av / "config.json").write_text(json.dumps({"ownerId": "own_only"}), encoding="utf-8")
+        assert identity_from_disk(cwd, home) is None
+
+    def test_reads_claim_agent_json_with_default_key(self, dirs):
+        cwd, home, av = dirs
+        (av / "agent.json").write_text(json.dumps({
+            "agent_id": "agt_claim", "owner_id": "own_claim", "proxy_url": "https://x.test",
+        }), encoding="utf-8")
+        ident = identity_from_disk(cwd, home)
+        assert ident["agent_id"] == "agt_claim"
+        assert Path(ident["key_path"]) == av / "agent.key"
+
+    def test_corrupt_config_is_ignored(self, dirs):
+        cwd, home, av = dirs
+        (av / "config.json").write_text("{not json", encoding="utf-8")
+        assert identity_from_disk(cwd, home) is None

agentvalet-0.2.0/src/agentvalet/env.py

@@ -1,119 +0,0 @@
-"""Environment resolution for ``AgentValet.from_env()``.
-
-Ported from ``packages/client/src/env.ts``. Accepts BOTH naming conventions
-already in the wild: the bare names the Node CLI and MCPB write
-(``AGENT_ID``, ``OWNER_ID``, ``PROXY_URL``, ``AGENT_PRIVATE_KEY*``) and
-``AGENTVALET_``-prefixed aliases, which is what the docs tell people to set.
-
-A machine that has run ``agentvalet register`` (or ``npx @agentvalet/register``)
-already satisfies the bare set, so ``from_env()`` works with no extra config.
-That property is the single most important onboarding affordance in the package
-— do not "tidy" it into one canonical name.
-"""
-
-from __future__ import annotations
-
-import base64
-import os
-from pathlib import Path
-
-from ._constants import DEFAULT_PROXY_URL
-from .errors import ConfigError
-
-__all__ = [
-    "agent_id_from_env",
-    "owner_id_from_env",
-    "private_key_from_env",
-    "proxy_url_from_env",
-    "session_id_from_env",
-]
-
-#: Written by the register flow. Also read by the Node SDK and mcp-server.
-KEY_PATH = Path.home() / ".agentvalet" / "agent.key"
-
-
-def _read_env(name: str) -> str | None:
-    """Empty strings and unresolved MCPB placeholders count as not-set.
-
-    The MCPB writes a literal ``${user_config.foo}`` when a field is left
-    blank. Treating that as a real value produces a baffling 401 much later,
-    far from the actual mistake.
-    """
-    raw = os.environ.get(name)
-    if raw is None:
-        return None
-    value = raw.strip()
-    if not value:
-        return None
-    if value.startswith("${") and value.endswith("}"):
-        return None
-    return value
-
-
-def _read_either(suffix: str) -> str | None:
-    """``AGENTVALET_``-prefixed name wins over the bare name when both are set."""
-    return _read_env(f"AGENTVALET_{suffix}") or _read_env(suffix)
-
-
-def agent_id_from_env() -> str | None:
-    return _read_either("AGENT_ID")
-
-
-def owner_id_from_env() -> str | None:
-    return _read_either("OWNER_ID")
-
-
-def proxy_url_from_env() -> str:
-    return (_read_either("PROXY_URL") or DEFAULT_PROXY_URL).rstrip("/")
-
-
-def session_id_from_env() -> str | None:
-    return _read_either("SESSION_ID")
-
-
-def private_key_from_env() -> str:
-    """Resolve the RS256 private key PEM.
-
-    Precedence, matching the Node SDK exactly:
-
-    1. ``AGENT_PRIVATE_KEY_B64``  — base64-encoded PEM (12-factor / container safe)
-    2. ``AGENT_PRIVATE_KEY_PATH`` — path to a PEM file
-    3. ``AGENT_PRIVATE_KEY``      — raw multi-line PEM, or ``\\n``-escaped single line
-    4. ``~/.agentvalet/agent.key`` — written by the register flow
-    """
-    b64 = _read_either("AGENT_PRIVATE_KEY_B64")
-    if b64:
-        return base64.b64decode(b64).decode("utf-8").strip()
-
-    path = _read_either("AGENT_PRIVATE_KEY_PATH")
-    if path:
-        try:
-            return Path(path).read_text(encoding="utf-8").strip()
-        except OSError as err:
-            raise ConfigError(f"Cannot read AGENT_PRIVATE_KEY_PATH ({path}): {err}") from err
-
-    raw = _read_either("AGENT_PRIVATE_KEY")
-    if raw:
-        unescaped = raw.replace("\\n", "\n")
-        # Secrets UIs routinely trim the PEM armour on paste. Re-wrap rather
-        # than failing deep inside the crypto layer with an opaque message.
-        if not unescaped.startswith("-----"):
-            return f"-----BEGIN PRIVATE KEY-----\n{unescaped}\n-----END PRIVATE KEY-----"
-        return unescaped
-
-    disk = _read_disk_key()
-    if disk:
-        return disk
-
-    raise ConfigError(
-        "No private key found. Set AGENT_PRIVATE_KEY, AGENT_PRIVATE_KEY_PATH, or "
-        "AGENT_PRIVATE_KEY_B64, or run `agentvalet register` to create an agent and "
-        "write ~/.agentvalet/agent.key."
-    )
-
-
-def _read_disk_key() -> str | None:
-    try:
-        return KEY_PATH.read_text(encoding="utf-8").strip() or None
-    except OSError:
-        return None

agentvalet-0.2.0/tests/test_env.py

@@ -1,94 +0,0 @@
-"""Mirrors ``packages/client/tests/env.test.ts``."""
-
-import base64
-
-import pytest
-
-from agentvalet._constants import DEFAULT_PROXY_URL
-from agentvalet.env import (
-    agent_id_from_env,
-    private_key_from_env,
-    proxy_url_from_env,
-    session_id_from_env,
-)
-from agentvalet.errors import ConfigError
-
-PEM = "-----BEGIN PRIVATE KEY-----\nAAAA\n-----END PRIVATE KEY-----"
-
-ALL_NAMES = [
-    "AGENTVALET_AGENT_ID", "AGENT_ID",
-    "AGENTVALET_OWNER_ID", "OWNER_ID",
-    "AGENTVALET_PROXY_URL", "PROXY_URL",
-    "AGENTVALET_AGENT_PRIVATE_KEY", "AGENT_PRIVATE_KEY",
-    "AGENTVALET_AGENT_PRIVATE_KEY_B64", "AGENT_PRIVATE_KEY_B64",
-    "AGENTVALET_AGENT_PRIVATE_KEY_PATH", "AGENT_PRIVATE_KEY_PATH",
-    "AGENTVALET_SESSION_ID", "SESSION_ID",
-]
-
-
-@pytest.fixture
-def clean_env(monkeypatch):
-    """Blank every consulted name so a real env var can't leak into a test."""
-    for name in ALL_NAMES:
-        monkeypatch.delenv(name, raising=False)
-    return monkeypatch
-
-
-class TestIdentity:
-    def test_prefixed_name_wins_over_bare(self, clean_env):
-        clean_env.setenv("AGENT_ID", "agt_bare")
-        clean_env.setenv("AGENTVALET_AGENT_ID", "agt_prefixed")
-        assert agent_id_from_env() == "agt_prefixed"
-
-    def test_falls_back_to_the_bare_name_the_cli_writes(self, clean_env):
-        clean_env.setenv("AGENT_ID", "agt_bare")
-        assert agent_id_from_env() == "agt_bare"
-
-    def test_unresolved_mcpb_placeholder_counts_as_not_set(self, clean_env):
-        # The MCPB writes a literal "${user_config.x}" for a blank field.
-        # Accepting it produces a baffling 401 far from the real mistake.
-        clean_env.setenv("AGENT_ID", "${user_config.agent_id}")
-        assert agent_id_from_env() is None
-
-    def test_proxy_url_defaults_and_strips_trailing_slash(self, clean_env):
-        assert proxy_url_from_env() == DEFAULT_PROXY_URL
-        clean_env.setenv("PROXY_URL", "https://self.hosted.test/")
-        assert proxy_url_from_env() == "https://self.hosted.test"
-
-    def test_session_id_absent_by_default(self, clean_env):
-        assert session_id_from_env() is None
-
-    def test_session_id_prefixed_name_wins_over_bare(self, clean_env):
-        clean_env.setenv("SESSION_ID", "sess_bare")
-        clean_env.setenv("AGENTVALET_SESSION_ID", "sess_prefixed")
-        assert session_id_from_env() == "sess_prefixed"
-
-
-class TestPrivateKey:
-    def test_base64_takes_precedence(self, clean_env):
-        clean_env.setenv("AGENT_PRIVATE_KEY_B64", base64.b64encode(PEM.encode()).decode())
-        assert private_key_from_env() == PEM
-
-    def test_reads_a_pem_file_by_path(self, clean_env, tmp_path):
-        path = tmp_path / "agent.key"
-        path.write_text(PEM, encoding="utf-8")
-        clean_env.setenv("AGENT_PRIVATE_KEY_PATH", str(path))
-        assert private_key_from_env() == PEM
-
-    def test_unreadable_path_raises_config_error_naming_it(self, clean_env, tmp_path):
-        missing = tmp_path / "definitely-not-here.key"
-        clean_env.setenv("AGENT_PRIVATE_KEY_PATH", str(missing))
-        with pytest.raises(ConfigError, match="definitely-not-here"):
-            private_key_from_env()
-
-    def test_unescapes_a_collapsed_single_line_pem(self, clean_env):
-        clean_env.setenv(
-            "AGENT_PRIVATE_KEY",
-            "-----BEGIN PRIVATE KEY-----\\nAAAA\\n-----END PRIVATE KEY-----",
-        )
-        assert private_key_from_env() == PEM
-
-    def test_rewraps_a_blob_that_lost_its_pem_armour(self, clean_env):
-        # Secrets UIs routinely trim the delimiters on paste.
-        clean_env.setenv("AGENT_PRIVATE_KEY", "AAAA")
-        assert private_key_from_env() == PEM