"""Run a vault fill, or an automatic one-time-code entry, inside the selected backend's ``fill_context`` (a plugin backend's lock/snapshot/manager session). Order, for every backend: the item's metadata is read and the page origin checked against it (``_bound_page_origin``) BEFORE the context is entered, so a page on the wrong origin never opens a backend's manager session or lock. Inside the context a backend with its own ``fill_context`` has the item re-read, so the origins checked and the secret resolved come from one snapshot. A plugin backend's failure arrives as ``PluginBackendError`` (fixed text, see ``agent/vault_backends/plugin.py``) and becomes a typed refusal; built-in backends behave as before. """ import json from functools import wraps def plugin_errors_as_refusal(fn): """A ``PluginBackendError`` raised anywhere in ``fn`` (metadata read, context enter/exit, resolve) becomes the ``backend_unavailable`` refusal.""" @wraps(fn) def wrapped(*args, **kwargs): from agent.vault_backends.plugin import PluginBackendError try: return fn(*args, **kwargs) except PluginBackendError as exc: return json.dumps({"success": False, "error_type": "backend_unavailable", "error": str(exc)}) return wrapped def saved_origins(meta) -> list[str]: """The exact origins a vault item may be filled on (several for manager items).""" return list(meta.allowed_origins) or ([str(meta.origin)] if meta.origin else []) def snapshot_refusal(backend, handle, meta, page_origin): """Inside ``fill_context``: ``None`` when the item still binds ``page_origin``, else the refusal. Only a backend with its own context is re-read (the built-in managers' metadata read is a full listing, and their default context freezes nothing).""" from agent.vault_backends.base import LoginBackend if type(backend).fill_context is LoginBackend.fill_context: return None fresh = backend.get_meta(handle) if fresh is not None and fresh.kind == meta.kind and page_origin in saved_origins(fresh): return None return {"success": False, "error_type": "origin_mismatch", "error": (f"Refused: the saved item changed before the fill and no longer binds {page_origin}. " "Nothing was resolved or written.")} def write_backend_code(backend, handle, meta, origin, write): """Mint the backend's one-time code for ``handle`` and ``write`` it, both inside ``fill_context``, as a password fill is. The caller has already checked ``origin`` against ``meta``. ``None`` when the backend has no code (or failed to give one): the caller asks the user.""" from agent.vault_backends.plugin import PluginBackendError written = None try: with backend.fill_context(): refusal = snapshot_refusal(backend, handle, meta, origin) if refusal is not None: return json.dumps(refusal) try: code = backend.resolve_otp(handle) except Exception: # health: allow BLE001 -- no automatic code; the user is asked instead code = None if code: written = write(code) except PluginBackendError: # the plugin's context failed to open or close; a code already written stands pass return written