Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

feat(vaults): support multi-field secrets and record delivery (#2563)

Call White20664d45bbe2
diff --git a/docs/plans/2026-10-13-vault-multi-field-secrets.md b/docs/plans/2026-10-13-vault-multi-field-secrets.md
new file mode 100644
index 000000000..3b0a807a2
--- /dev/null
+++ b/docs/plans/2026-10-13-vault-multi-field-secrets.md
@@ -0,0 +1,296 @@
+# Vault multi-field secrets
+
+Status: P1 contract. The owner approved the direction and the four decisions in
+section 2 on 2026-10-13.
+
+Related: `vaults-grant-delivery-refactor.md` (current grant and delivery model),
+`avault-custody-core.md`, `vault-sandbox-protocol-v2.md`, and
+`../avault/docs/DESIGN.md` (authoritative envelope and AAD design).
+
+## 1. Background
+
+A user asked for one Vault entry to hold several secret values, like a
+1Password item: a login has a username, a password, and a 2FA secret. Today a
+Vault secret holds exactly one value, so a login becomes three unrelated
+secrets.
+
+## 2. Goal and decisions
+
+One secret can hold several named fields. Agents reference a field as
+`NAME.field`. Values still never enter the model context, and avault's
+cryptography and wire formats do not change.
+
+Approved decisions:
+
+1. A secret has one **default field** (its existing value) plus optional
+ **extra fields**.
+2. Authorization stays per secret. Approving a protected secret releases the
+ DEKs of all its fields, and grants still list secret names.
+3. `--tag` and `--skill` deliver every field of each selected secret. `--env`
+ still maps exactly one value to one variable.
+4. P1 can replace the value of any field, including the default field.
+
+Built-in 2FA code generation is P2 (section 13).
+
+## 3. Names and records (shared contract)
+
+| Term | Grammar |
+| --- | --- |
+| Secret name (unchanged) | `^[A-Za-z_][A-Za-z0-9_]*$` |
+| Field name | `^[a-z][a-z0-9_]{0,63}$` |
+| Record name | `^[A-Za-z_][A-Za-z0-9_]*(\.[a-z][a-z0-9_]{0,63})?$` |
+
+- A **record** is one encrypted value. The default field's record name is the
+ bare secret name (`GITHUB_LOGIN`), whatever the default field is called. An
+ extra field's record name is `<secret>.<field>` (`GITHUB_LOGIN.username`).
+ `<secret>.<default field name>` is never a record name.
+- A **ref** is what users and agents write: `NAME` or `NAME.field`. Both `NAME`
+ and `NAME.<default field name>` resolve to the default record.
+- Existing secrets have a default field named `value` and no extra fields.
+- Field names are unique within a secret, including the default field's name.
+ A secret has at most 32 fields, counting the default field.
+- Extra field names are immutable because their ciphertext binds the record
+ name. To rename one, remove it and add it again. The default field's name is
+ only a label and can be renamed. Which field is the default is fixed when the
+ secret is created.
+- Only `static` secrets can have extra fields. Keypair secrets keep one implicit
+ `value` field: create/PATCH reject an explicit `default_field`, and refs such
+ as `KEY.field` are rejected.
+
+Every envelope binds its record name:
+
+- Standard tier: avault seals and opens with AAD
+ `record || "machine-aesgcm-v1" || 0x01`.
+- Protected tier: the protected-record v2 AAD JSON carries
+ `"name": "<record>"` and `"record": {"kind": "static"}`.
+- Blind boxes: the `name` AAD field is the record name for `seal` and
+ `agent-deliver`, and the agent-deliver `operation_hash` covers the record
+ name.
+
+avault already treats this name as an opaque string. A probe with avault 0.1.6
+and a temporary file store delivered `GH.username` and `GH` to one child process,
+and rejected a `GH.username` envelope presented as `GH.password` or `GH`. The
+vault-sandbox crypto validator still accepts only secret names, so it must
+accept record names before protected secrets can have extra fields.
+
+## 4. Storage
+
+- New nullable TEXT column `vault_secrets.fields`. It holds a JSON array of the
+ extra fields in display order:
+
+ ```json
+ [{"name": "username", "ciphertext": "...", "nonce": "...", "wrap_meta": "...",
+ "created_at": "...", "updated_at": "..."}]
+ ```
+
+ NULL or `[]` means no extra fields.
+- The default field keeps the existing `ciphertext`, `nonce`, and `wrap_meta`
+ columns unchanged.
+- The default field's name is `public_meta.default_field`. When it is absent
+ or invalid, the name is `value`.
+- All fields share the secret's `kind`, `protection`, tags, policy, resource
+ access policy, and audit history.
+- Every envelope change bumps `vault_secrets.updated_at`, so stale approval
+ material is detected through the existing member versions. Field writes are
+ atomic per secret: a concurrent change fails as a conflict, never as a lost
+ update.
+- The migration adds the column and its downgrade drops it. Released versions
+ ignore the column and keep reading the default value. The `vibe data query`
+ denylist already covers `vault_secrets`.
+
+## 5. Value-free metadata
+
+The secret metadata payload (`_meta_payload`, REST, and `vibe vault list/find
+--json`) adds two keys:
+
+- `default_field`: the default field's name.
+- `fields`: every field name, default field first, then extra fields in stored
+ order. An existing secret shows `"default_field": "value", "fields": ["value"]`.
+
+- A corrupt extra-field section adds `"fields_state": "corrupt"` to this
+ value-free metadata, while `fields` exposes only the available default. Web
+ rows/editors warn about the corruption, and tag/skill expansion refuses to
+ deliver a partial field set.
+
+## 6. Delivery
+
+| Selector | Records | Environment variable |
+| --- | --- | --- |
+| `--env NAME` | default record | `NAME` |
+| `--env NAME.field` | that field's record | `NAME_<FIELD>` |
+| `--env LOCAL=NAME[.field]` | the referenced record | `LOCAL` |
+| `--tag T`, `--skill S` | every record of each selected static secret | default record as `NAME`; each extra field as `NAME_<FIELD>` |
+
+- `<FIELD>` is the field name in upper case: `GITHUB_LOGIN.username` becomes
+ `GITHUB_LOGIN_USERNAME`. The rule also applies when the ref names the default
+ field: `GITHUB_LOGIN.password` becomes `GITHUB_LOGIN_PASSWORD` and delivers
+ the record `GITHUB_LOGIN`.
+- Conflicts fail before delivery, as today but per record: one record selected
+ under two variable names, or one variable name mapped to two records.
+- An unknown field fails with a `field_not_found` error that lists the secret's
+ fields. Keypair rejection (`keypair_not_value_deliverable`) is unchanged.
+- `vibe vault fetch --auth NAME[.field]` attaches that record. The allowed
+ hosts and auth scheme come from the secret's policy.
+- `vibe vault inject` accepts the same selectors as `run`, including field refs.
+ Avibe always sends an explicit `key`, because avault's fallback key would be
+ the record name, which is not a valid key.
+- `vibe vault export` stays deprecated and returns `export_deprecated`, with no
+ delivery. Its parser and help are unchanged.
+- Commands that only authorize, such as `vibe vault access`, accept
+ `NAME.field` and authorize the secret.
+- Every avault entry carries `name` = record name, that record's `envelope`,
+ and `tier` = the secret's protection.
+- Completed delivery bookkeeping uses the secret/field identities captured in
+ the pre-delivery plan, not a second record lookup. Removing or renaming a
+ field while a child runs must not drop its audit or the rest of the batch.
+- Use counts stay per secret. The delivery audit lists the delivered fields.
+
+## 7. Authorization
+
+- Grants, access requests, `always_ask`, and one-shot handling stay keyed by
+ secret names. `member_snapshot` keeps listing secret names.
+- A protected DEK release covers every record of each protected member:
+ - Approval card `grant_options[].unlock_material` carries one material per
+ record, named by record name.
+ - The agent-binding batch issues one signed release context per record, with
+ the operation hash over the record name. The signed `display.secrets` lists
+ every record (`{"name": "<record>", "kind": "static"}`) because the sandbox
+ requires the display block to cover each release item.
+ - Grant creation requires the submitted DEK names to equal the record names
+ of the protected members.
+- Within a live grant, delivery may use any record of a covered secret.
+- Any envelope change expires the secret's pending requests and active grants,
+ and releases resident avault scopes, as rotate and delete do today.
+- The approval card shows each member's field names.
+
+## 8. API
+
+- `POST /api/vault/secrets` accepts an optional `default_field` and optional
+ `fields`: `[{"name", "record", "blind_box"}]` for standard secrets or
+ `[{"name", "record", "sealed"}]` for protected secrets. The top-level `blind_box` or
+ `sealed` is still the default field. For standard secrets Python seals each
+ field with `avault seal --name <record> --blind-box`. Keypairs reject `fields`.
+- `PUT /api/vault/secrets/{name}/fields/{field}` takes `{"record", "blind_box"}`
+ or `{"record", "sealed"}`. For the default field it replaces the default envelope.
+ Otherwise it adds the field (appended) or replaces its value. It returns the
+ masked metadata.
+- `DELETE /api/vault/secrets/{name}/fields/{field}` removes an extra field. The
+ browser sends `{"expected_updated_at": "<displayed version>"}` so deleting a
+ field changed in another tab returns 409 `secret_conflict`. The default field
+ cannot be removed (409).
+- `PATCH /api/vault/secrets/{name}` also accepts `default_field` to rename the
+ default field. The name must be valid and unused; this is pure metadata and
+ leaves envelope versions, pending requests, and active grants unchanged.
+- `POST /api/vault/secrets/{name}/reveal-context` accepts an optional `field`
+ and returns the context and envelope of that record.
+- Every extra create field and field PUT declares the `record` name used to
+ seal it; the server rejects a mismatch with its current field resolution as
+ 409 `record_mismatch` without storing anything, and the UI re-reads metadata
+ and re-seals once (the top-level create record is implicitly `NAME`).
+- New error codes: `invalid_field_name`, `field_exists`, `field_not_found`,
+ `too_many_fields`, `fields_not_supported`, `record_mismatch`, `fields_corrupt`.
+ Corrupt extra-field storage is warned about and unavailable as a whole; the
+ default record remains usable, while field mutations preserve the original
+ bytes and refuse until the stored section is repaired.
+- Plaintext rejection, resource-access checks, SSE updates, and audit apply to
+ every new path. Field changes audit as `updated` with
+ `{"field": "<name>", "op": "add" | "replace" | "remove"}`.
+- The browser derives the record name (`NAME` for the default field,
+ `NAME.field` otherwise) and seals with it: standard secrets use
+ `standardCreateBlindBoxContext(record)`, protected secrets use the sandbox
+ `seal({name: record, kind: "static"})`.
+
+## 9. Provision requests
+
+The request spec gains `fields` (field names in display order) and
+`default_field` (one of `fields`; defaults to the first). They never carry
+values.
+
+```bash
+vibe vault request GITHUB_LOGIN --reason "Log in to GitHub" \
+ --spec-json '{"protection":"protected","fields":["username","password","totp"],"default_field":"password"}'
+```
+
+The browser form starts with those rows. The user may remove rows, and every
+submitted field needs a value. Field-aware provision replies (asynchronous
+callbacks, synchronous `--wait`, and already-existing results) list current field
+labels and the default alias from the created secret, not the requested spec,
+and share the same field-ref delivery hint. A user-created multi-field shape
+also receives this hint when the original request had no field spec.
+
+## 10. UI
+
+- Create: a static secret looks the same as today until the user adds a field.
+ Then the value becomes a list of field rows (name and value), with exactly one
+ default. A Login template fills `username`, `password` (default), and `totp`.
+ File upload stays available only for a single-value standard secret.
+- A protected create seals every field in the same sandbox session and sends
+ one create request. Vault establishment fields are sent once.
+- Edit: replace any field's value, add or remove extra fields, and rename the
+ default field. Name, kind, and protection stay read-only. After mount the
+ editor owns current server metadata and drafts: own-write responses or
+ sequenced authoritative refetches update truth, while changed parent props
+ and Vault events trigger refetches rather than directly replacing it. Only
+ the latest refetch may apply. Draft reconciliation preserves retained labels,
+ moves a renamed default draft, notices removed drafts, and preserves a dirty
+ label input unless its own rename succeeds.
+- List and detail show field names when a secret has more than one field.
+- Protected reveal works per field.
+- The approval card groups records by secret and shows field names.
+- Strings go through `ui/src/i18n/{en,zh}.json`; reuse the existing primitives.
+
+## 11. Cross-repository work
+
+| Repository | Change |
+| --- | --- |
+| avibe | Storage, service, API, CLI, UI, `use-avibe-vault` skill, tests |
+| vault-sandbox | Accept record names in crypto-name validation, with tests |
+| avault | DESIGN documents the record-name convention; vectors and tests pin field records; no code change |
+| avibe-docs | Vault concept page in English and Chinese |
+
+The sandbox change only widens accepted names, so it can deploy first. Standard
+secrets with fields work without it; protected secrets with fields need it.
+
+## 12. Validation
+
+- Existing secrets keep their delivery behavior; their metadata adds only
+ `default_field` and `fields`.
+- New paths accept no plaintext.
+- Fields are sealed and delivered under their record names; avault tests show
+ a field envelope does not open under another record name.
+- Selectors cover refs, variable naming, tag and skill expansion with extra
+ fields, conflicts, unknown fields, and keypair rejection.
+- Protected approval releases every record, delivery of any field works under
+ the grant, and a field change expires the grant.
+- The migration upgrades and downgrades with existing rows.
+- The skill's CLI examples parse.
+
+## 13. Out of scope for P1
+
+- **2FA codes (P2).** A `totp` field type. avault computes the current code at
+ delivery, so the child gets the code and never the seed, and sandbox reveal
+ shows a live code. This needs avault (HMAC-SHA1/256/512, base32, `otpauth://`
+ parsing) with a DESIGN update, the sandbox, and Python type metadata. Until
+ then a 2FA secret can be stored as an ordinary field.
+- HTTP Basic auth in `fetch` from a username and password field.
+- 1Password import that maps item fields to Vault fields.
+
+## 14. Known by design
+
+- Approving a protected secret unlocks all its fields for the grant's lifetime.
+- Extra field names and the choice of default field cannot change after
+ creation.
+- Standard values stay hidden in the UI.
+- The CLI cannot write fields; values enter only through the browser.
+- `export` remains deprecated and never delivers values. Agent-initiated field
+ deletion is out of scope; browser/REST removal of extra fields is supported.
+- There are no plaintext or non-secret fields; non-secret notes belong in the
+ description.
+- Web field errors are localized from the canonical stable-code tuple in
+ `vibe/api.py`, guarded against both catalogs; agent-facing CLI/service
+ diagnostic text stays English.
+- VMK-copy discovery (`latest_protected_vmk_wrap_meta`) selects the default
+ envelope on the most recently updated secret. Updating an extra field can
+ move a secret with older VMK copies to the front. This is latent while the
+ sandbox writes the base VMK wrap only at setup; multi-passkey/VMK-copy changes
+ must replace this selection before allowing those copies to diverge.
diff --git a/skills/use-avibe-vault/SKILL.md b/skills/use-avibe-vault/SKILL.md
index 7e0b07b24..15a59ca83 100644
--- a/skills/use-avibe-vault/SKILL.md
+++ b/skills/use-avibe-vault/SKILL.md
@@ -2,7 +2,7 @@
name: use-avibe-vault
slug: use-avibe-vault
description: Use Avibe Vault for API keys, tokens, passwords, protected credentials, authenticated HTTP requests, or digest signing without exposing secret values to the agent.
-version: 0.2.0
+version: 0.3.0
---
# Use Avibe Vault
@@ -11,13 +11,18 @@ When a task needs API keys, access tokens, passwords, wallet private keys, or ot
Core concepts:
- Static secret: a regular secret value, such as an API key, token, database password, or deployment credential. Use it with `vibe vault run` for environment injection or `vibe vault fetch` for authenticated HTTP egress.
+- A static secret can contain up to 32 named fields. `NAME` selects its default field (existing secrets call it `value`); `NAME.field` selects that field, including an explicit default label such as `GITHUB_LOGIN.password`. Field names match `^[a-z][a-z0-9_]{0,63}$`. The default label may be renamed; extra labels and the choice of default cannot change after creation.
- Keypair secret: a signing key for digests or transactions, such as a wallet key or deployment signer. It cannot be exported as an environment variable and cannot be used with `run` / `fetch`; use `vibe vault sign`.
- Standard: for lower-risk routine automation. Agents can usually use it without interrupting the user unless it is configured to ask first.
- Protected: for high-risk secrets, such as production databases or wallet/funds keys. Because protected secrets are end-to-end encrypted, use requires browser approval and passkey unlock.
Rules:
-- Refer to secrets only by secret name, tag, or skill tag.
-- Static secrets can be used with `run` / `fetch`; keypair secrets can only be used with `vibe vault sign`.
+- Refer to secrets only by secret name, record ref (`NAME.field`), tag, or skill tag.
+- Static secrets can be used with `run` / `fetch`; keypair secrets can only be used with `vibe vault sign`. Keypairs do not accept field refs.
+- Authorization is per secret: approving a protected secret unlocks **all its fields** for the grant's lifetime. The CLI cannot create, replace, or delete fields; the user does that in the browser.
+- `--env NAME.field` delivers one value to `NAME_FIELD` (only the field is uppercased); `--env LOCAL=NAME.field` chooses the variable. `--tag` and `--skill` deliver every field of each selected secret, using `NAME` for the default and `NAME_FIELD` for extras. Conflicting variable mappings fail before delivery.
+- `list` and `find` return value-free `default_field` and `fields` metadata. If a ref fails with `field_not_found`, use the listed field names rather than guessing.
+- `export` remains deprecated and has no delivery. Prefer `run`; advanced `inject` writes a restricted-permission file, so use it only for tools that require file-based configuration.
- With `vibe vault run`, the child process receives static secrets as environment variables, so never run commands that may print env vars, debug config, or secret-bearing errors.
- When protected `run` / `fetch` needs approval, Avibe automatically asks the user to decrypt and authorize access. After the user approves, Avibe resumes this session; it does not replay the command for you, so run the same `run` / `fetch` command again.
- When protected `sign` needs approval, Avibe creates a browser signing request and returns immediately. Do not rerun `sign`; when Avibe resumes this session, follow the callback instruction to read the completed request result and continue with the returned signature.
@@ -27,6 +32,11 @@ Common commands:
Request that the user add a missing static secret. `spec-json` may contain only non-secret prefill metadata; the actual secret value is entered by the user in the browser:
`vibe vault request OPENAI_API_KEY --reason "Need OpenAI API access" --spec-json '{"kind":"static","protection":"protected","description":"OpenAI API key","tags":["openai","prod","skill:model-work"],"policy":{"allowed_hosts":["api.openai.com"],"auth":{"type":"bearer"}}}'`
+Request a multi-field login item with a password default. These are field names only, never values:
+`vibe vault request GITHUB_LOGIN --reason "Log in to GitHub" --spec-json '{"protection":"protected","fields":["username","password","totp"],"default_field":"password"}'`
+
+A `totp` field is ordinary stored secret material in this version, not a generated one-time code.
+
For a missing keypair/signing key, ask the user to create a keypair secret in the Vault UI; do not request or store private-key material as a static secret.
On Avibe Web chat, a lighter manual prompt can mention the missing secret as a clickable placeholder in your reply, for example `$<OPENAI_API_KEY>`. The user can click it and fill the secret from Web chat. This has no reason or structured prefill metadata; use `vibe vault request` when those are needed.
@@ -40,19 +50,26 @@ List or find existing Vault entries:
Run a command with selected static secrets injected as environment variables:
`vibe vault run --env OPENAI_API_KEY,GITHUB_TOKEN -- python script.py`
-`vibe vault run --env GITHUB_TOKEN=GH_PAT --env OPENAI_API_KEY -- python script.py`
+`vibe vault run --env GITHUB_LOGIN.username -- python script.py`
+`vibe vault run --env PASSWORD=GITHUB_LOGIN.password -- python script.py`
`vibe vault run --tag deploy -- ./deploy.sh`
`vibe vault run --skill github-release -- ./release.sh`
Make an authenticated HTTP request. The credential is attached only at egress, and the agent never sees the secret:
-`vibe vault fetch --auth GITHUB_PAT --url https://api.github.com/user`
+`vibe vault fetch --auth GITHUB_API.token --url https://api.github.com/user`
+
+The secret's allowed hosts and auth scheme apply to every field; this attaches one field, not a username/password pair.
+
+For tools that require a file, `inject` uses the same selectors and explicit output keys:
+`vibe vault inject --env USERNAME=GITHUB_LOGIN.username --env PASSWORD=GITHUB_LOGIN.password --out login.env --format dotenv`
+`vibe vault inject --tag deploy --out deploy.json --format json`
Request approval before a protected `run` with an existing static secret:
-`vibe vault access PROD_DB_URL --skill deploy --command "run database migration" --egress "connect to production database"`
+`vibe vault access GITHUB_LOGIN.password --skill deploy --command "Log in to GitHub" --egress "github.com"`
For protected `fetch`, run `vibe vault fetch`; it creates the correct fetch approval request when needed.
Sign a 32-byte digest with a keypair secret. Standard keys may return the signature directly; protected keys create a browser approval request:
-`vibe vault sign WALLET_KEY --digest <64-hex-digest> --scheme ecdsa-secp256k1-recoverable --command "sign deployment transaction"`
+`vibe vault sign WALLET_KEY --digest 0000000000000000000000000000000000000000000000000000000000000001 --scheme ecdsa-secp256k1-recoverable --command "sign deployment transaction"`
For more details, run `vibe vault --help`.
diff --git a/storage/alembic/versions/20261013_0065_vault_secret_fields.py b/storage/alembic/versions/20261013_0065_vault_secret_fields.py
new file mode 100644
index 000000000..9f8d9b777
--- /dev/null
+++ b/storage/alembic/versions/20261013_0065_vault_secret_fields.py
@@ -0,0 +1,39 @@
+"""Add named extra fields to Vault secrets.
+
+Revision ID: 20261013_0065
+Revises: 20261012_0064
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "20261013_0065"
+down_revision = "20261012_0064"
+branch_labels = None
+depends_on = None
+MIGRATION_SAFETY = "additive"
+
+
+def _columns() -> set[str]:
+ bind = op.get_bind()
+ return {str(row[1]) for row in bind.exec_driver_sql("pragma table_info(vault_secrets)")}
+
+
+def upgrade() -> None:
+ if "fields" not in _columns():
+ op.add_column("vault_secrets", sa.Column("fields", sa.Text(), nullable=True))
+
+
+def downgrade() -> None:
+ if "fields" in _columns():
+ # SQLite before 3.35 cannot DROP COLUMN. Batch rebuilding also preserves
+ # the ordinary name constraint/index, but reflection skips expression
+ # indexes, so restore the folded-name uniqueness guard explicitly.
+ with op.batch_alter_table("vault_secrets") as batch:
+ batch.drop_column("fields")
+ op.get_bind().exec_driver_sql(
+ "create unique index if not exists uq_vault_secrets_name_folded "
+ "on vault_secrets (lower(name))"
+ )
diff --git a/storage/migrations.py b/storage/migrations.py
index c3d26e18e..b52ce6a4d 100644
--- a/storage/migrations.py
+++ b/storage/migrations.py
@@ -158,6 +158,7 @@ HEAD_REQUIRED_COLUMNS = PRE_SHOW_SESSION_EVENTS_REQUIRED_COLUMNS | {
},
}
HEAD_ONLY_REQUIRED_COLUMNS = {
+ "vault_secrets": {"fields"},
"show_pages": {"access_mode", "access_revision", "share_id", "offline_at"},
"show_page_access_entries": {
"page_id",
@@ -710,6 +711,9 @@ def _repair_head_required_columns(conn: sqlite3.Connection, tables: set[str]) ->
if table in tables and "context_seq" not in _column_names(conn, table):
conn.execute(f'alter table "{table}" add column "context_seq" INTEGER')
changed = True
+ if "vault_secrets" in tables and "fields" not in _column_names(conn, "vault_secrets"):
+ conn.execute('alter table "vault_secrets" add column "fields" TEXT')
+ changed = True
_ensure_head_indexes(conn, tables)
return changed
diff --git a/storage/models.py b/storage/models.py
index 4d122bad5..5e25a4181 100644
--- a/storage/models.py
+++ b/storage/models.py
@@ -1260,6 +1260,9 @@ vault_secrets = Table(
Column("ciphertext", Text, nullable=True),
Column("nonce", Text, nullable=True),
Column("wrap_meta", Text, nullable=True),
+ # JSON array of extra named field envelopes. The default field remains in the
+ # legacy ciphertext/nonce/wrap_meta columns for released-version compatibility.
+ Column("fields", Text, nullable=True),
Column("public_meta", Text, nullable=True), # JSON: desc / pubkey / address / op:// uri
Column("policy", Text, nullable=True), # JSON: allowed modes, allowed hosts, always_ask
Column("last_used_at", String, nullable=True),
diff --git a/storage/vault_service.py b/storage/vault_service.py
index 63c51200e..c716e8f48 100644
--- a/storage/vault_service.py
+++ b/storage/vault_service.py
@@ -22,6 +22,7 @@ import threading
import uuid
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
+from functools import lru_cache
from typing import Any
from urllib.parse import urlsplit
@@ -91,7 +92,11 @@ PROVISION_SPEC_ALLOWED_KEYS = {
"tags",
"policy",
"links",
+ "fields",
+ "default_field",
}
+PROVISION_FIELD_NAME_RE = re.compile(r"^[a-z][a-z0-9_]{0,63}$")
+MAX_SECRET_FIELDS = 32
PROVISION_SPEC_ALLOWED_POLICY_KEYS = {"allowed_hosts", "auth"}
PROVISION_SPEC_ALLOWED_AUTH_KEYS = {"type", "name"}
FETCH_AUTH_HEADER_NAME_RE = re.compile(r"^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$")
@@ -100,6 +105,16 @@ FORBIDDEN_FETCH_AUTH_HEADER_NAMES = frozenset({"host"})
_UNSET = object()
+@dataclass(frozen=True)
+class DeliveryIdentity:
+ """Value-free pre-handoff identity retained for post-delivery bookkeeping."""
+
+ secret_id: str
+ name: str
+ field: str
+ access_snapshot: dict[str, Any] | None
+
+
@dataclass(frozen=True)
class GrantApproval:
grant_id: str
@@ -149,6 +164,38 @@ class SecretExistsError(VaultServiceError):
pass
+class InvalidFieldNameError(VaultServiceError):
+ pass
+
+
+class FieldExistsError(VaultServiceError):
+ pass
+
+
+class FieldNotFoundError(VaultServiceError):
+ pass
+
+
+class TooManyFieldsError(VaultServiceError):
+ pass
+
+
+class FieldsNotSupportedError(VaultServiceError):
+ pass
+
+
+class FieldsCorruptError(VaultServiceError):
+ pass
+
+
+class RecordMismatchError(VaultServiceError):
+ pass
+
+
+class SecretConflictError(VaultServiceError):
+ pass
+
+
class SecretNameCaseConflictError(VaultServiceError):
def __init__(self, name: str, existing_name: str):
self.name = name
@@ -309,6 +356,14 @@ def _parse_iso_datetime(value: str | None) -> datetime | None:
return parsed.astimezone(timezone.utc)
+def _next_updated_at(previous: str | None = None) -> str:
+ current = datetime.now(timezone.utc)
+ previous_dt = _parse_iso_datetime(previous)
+ if previous_dt is not None and current <= previous_dt:
+ current = previous_dt + timedelta(microseconds=1)
+ return current.isoformat()
+
+
def _id(prefix: str) -> str:
return f"{prefix}_{uuid.uuid4().hex[:12]}"
@@ -511,6 +566,148 @@ def _public_meta(raw: str | None) -> dict[str, Any]:
return payload if isinstance(payload, dict) else {}
+def _validate_field_name(name: Any, *, field: str = "field") -> str:
+ if not isinstance(name, str) or not PROVISION_FIELD_NAME_RE.fullmatch(name):
+ raise InvalidFieldNameError(f"{field} must match ^[a-z][a-z0-9_]{{0,63}}$")
+ return name
+
+
+def _default_field_name(row: dict[str, Any] | None = None, value: Any = None) -> str:
+ if row is not None and row.get("kind") == "keypair":
+ return "value"
+ candidate = value
+ if candidate is None and row is not None:
+ candidate = _public_meta(row.get("public_meta")).get("default_field")
+ try:
+ return _validate_field_name(candidate or "value", field="default_field")
+ except InvalidFieldNameError:
+ return "value"
+
+
+@lru_cache(maxsize=512)
+def _warn_corrupt_fields(name: str, secret_id: str, updated_at: str) -> None:
+ """Bounded warning cache: repeated reads of one damaged revision stay quiet."""
+ logger.warning("Vault secret %s has corrupt fields; extra records and field mutations are unavailable", name)
+
+
+def _extra_field_rows(row: dict[str, Any] | None, *, strict: bool = False) -> list[dict[str, Any]]:
+ """Read the complete optional section, never a lossy partial projection.
+
+ Default-record reads remain available when extras are corrupt. Any caller
+ that writes fields or needs an extra record must fail closed instead.
+ """
+ if not row or row.get("fields") is None:
+ return []
+ try:
+ raw = json.loads(row["fields"])
+ if not isinstance(raw, list) or len(raw) >= MAX_SECRET_FIELDS:
+ raise ValueError("invalid field array")
+ seen = {_default_field_name(row)}
+ if row.get("kind") == "keypair" and raw:
+ raise ValueError("keypair has extra fields")
+ for item in raw:
+ if not isinstance(item, dict):
+ raise ValueError("invalid field entry")
+ name = _validate_field_name(item.get("name"))
+ if name in seen:
+ raise ValueError("duplicate field label")
+ if not all(isinstance(item.get(key), str) and item[key] for key in ("ciphertext", "nonce", "wrap_meta", "created_at", "updated_at")):
+ raise ValueError("incomplete field envelope")
+ seen.add(name)
+ return [dict(item) for item in raw]
+ except (TypeError, ValueError, InvalidFieldNameError):
+ # Neither malformed serialized values nor exception details are safe to log.
+ _warn_corrupt_fields(str(row.get("name") or ""), str(row.get("id") or ""), str(row.get("updated_at") or ""))
+ if strict:
+ raise FieldsCorruptError(f"secret {row.get('name')!r} has corrupt fields; existing data was preserved") from None
+ return []
+
+
+def secret_field_names(row: dict[str, Any]) -> list[str]:
+ return [_default_field_name(row), *[str(item["name"]) for item in _extra_field_rows(row, strict=False)]]
+
+
+def record_name_for_field(secret_name: str, field_name: str, *, default_field: str = "value") -> str:
+ return secret_name if field_name == default_field else f"{secret_name}.{field_name}"
+
+
+def _record_entries(row: dict[str, Any], *, strict: bool = False) -> list[dict[str, Any]]:
+ default_field = _default_field_name(row)
+ entries = [
+ {
+ "name": row["name"],
+ "field": default_field,
+ "envelope": _row_sealed(row),
+ "kind": row.get("kind"),
+ "protection": row.get("protection"),
+ }
+ ]
+ for field in _extra_field_rows(row, strict=strict):
+ entries.append(
+ {
+ "name": record_name_for_field(str(row["name"]), str(field["name"]), default_field=default_field),
+ "field": str(field["name"]),
+ "envelope": Sealed(
+ ciphertext=field["ciphertext"], nonce=field["nonce"], wrap_meta=field["wrap_meta"]
+ ),
+ "kind": row.get("kind"),
+ "protection": row.get("protection"),
+ }
+ )
+ return entries
+
+
+def _resolve_record_ref(conn: Connection, ref: str, *, user_context: Any = None) -> tuple[dict[str, Any], dict[str, Any]]:
+ raw = str(ref or "").strip()
+ parts = raw.split(".", 1)
+ secret_name = parts[0]
+ if not vault_crypto.is_valid_secret_name(secret_name):
+ raise InvalidSecretNameError(secret_name)
+ row = require_secret_access(conn, secret_name, user_context=user_context)
+ field_ref = parts[1] if len(parts) == 2 else None
+ default_field = _default_field_name(row)
+ if field_ref is not None and row.get("kind") == "keypair":
+ raise FieldsNotSupportedError(f"{secret_name} does not support fields")
+ if field_ref is None or field_ref == default_field:
+ field_name = default_field
+ else:
+ _validate_field_name(field_ref)
+ if field_ref not in {str(item["name"]) for item in _extra_field_rows(row, strict=True)}:
+ raise FieldNotFoundError(f"field {field_ref!r} not found on {secret_name}; fields: {', '.join(secret_field_names(row))}")
+ field_name = field_ref
+ entry = next(item for item in _record_entries(row) if item["field"] == field_name)
+ return row, entry
+
+
+def validate_field_name(value: Any, *, field: str = "field") -> str:
+ return _validate_field_name(value, field=field)
+
+
+def secret_record_names(secret: dict[str, Any]) -> list[str]:
+ name = str(secret.get("name") or "")
+ default_field = str(secret.get("default_field") or _default_field_name(secret))
+ raw_fields = secret.get("fields")
+ fields = raw_fields if isinstance(raw_fields, list) else [default_field]
+ result = [name]
+ for raw_field in fields:
+ field = str(raw_field)
+ if field != default_field:
+ result.append(f"{name}.{field}")
+ return result
+
+
+def get_secret_record_meta(conn: Connection, ref: str, *, user_context: Any = None) -> dict[str, Any]:
+ row, entry = _resolve_record_ref(conn, ref, user_context=user_context)
+ payload = _meta_payload(row)
+ payload["record_name"] = str(entry["name"])
+ payload["field"] = str(entry["field"])
+ return payload
+
+
+def require_secret_management(conn: Connection, name: str, *, user_context: Any = None) -> dict[str, Any]:
+ return _require_secret_resource_management(conn, _require_row(conn, name), resolve_resource_access_context(user_context))
+
+
def _reject_provision_spec_secret_fields(value: Any, *, path: str = "spec") -> None:
if isinstance(value, dict):
for key, item in value.items():
@@ -703,6 +900,25 @@ def normalize_provision_spec(spec: Any) -> dict[str, Any]:
tags = _string_list(spec.get("tags"), field="spec.tags") if "tags" in spec else []
tags = _normalize_tags(tags)
+ if "fields" in spec:
+ raw_fields = spec.get("fields")
+ if not isinstance(raw_fields, list):
+ raise VaultServiceError("spec.fields must be an array of field names")
+ fields = [_validate_field_name(item, field="spec.fields") for item in raw_fields]
+ if len(fields) != len(set(fields)):
+ raise VaultServiceError("spec.fields must contain unique field names")
+ if not fields:
+ raise VaultServiceError("spec.fields must contain at least one field")
+ if len(fields) > MAX_SECRET_FIELDS:
+ raise TooManyFieldsError(f"a vault secret can have at most {MAX_SECRET_FIELDS} fields")
+ normalized["fields"] = fields
+ default_field = spec.get("default_field", fields[0])
+ default_field = _validate_field_name(default_field, field="spec.default_field")
+ if default_field not in fields:
+ raise VaultServiceError("spec.default_field must be one of spec.fields")
+ normalized["default_field"] = default_field
+ elif "default_field" in spec:
+ raise VaultServiceError("spec.default_field requires spec.fields")
if "policy" in spec:
normalized_policy = _normalize_fetch_policy(spec.get("policy"), field="spec.policy")
if normalized_policy:
@@ -733,7 +949,7 @@ def _meta_payload(row: dict[str, Any]) -> dict[str, Any]:
kind = row.get("kind")
protection = row.get("protection")
payload = {
- "name": row["name"],
+ **_field_metadata(row),
"tags": _row_tags(row),
"kind": kind,
"protection": protection,
@@ -775,10 +991,16 @@ def _row_sealed(row: dict[str, Any]) -> Sealed:
def _protected_unlock_material(row: dict[str, Any]) -> dict[str, Any] | None:
+ """Return the default record's opaque protected unlock material.
+
+ This single-object shape is still used by signing and reveal cards. Grant
+ options use ``_protected_unlock_material_records`` so every record is
+ covered without changing this legacy surface.
+ """
if row.get("protection") != "protected":
return None
return {
- "name": row["name"],
+ "name": str(row["name"]),
"kind": row.get("kind"),
"envelope": {
"ciphertext": row["ciphertext"],
@@ -788,6 +1010,27 @@ def _protected_unlock_material(row: dict[str, Any]) -> dict[str, Any] | None:
}
+def _protected_unlock_material_records(row: dict[str, Any]) -> list[dict[str, Any]]:
+ if row.get("protection") != "protected":
+ return []
+ materials: list[dict[str, Any]] = []
+ for entry in _record_entries(row):
+ envelope = entry["envelope"]
+ materials.append(
+ {
+ "name": entry["name"],
+ "field": entry["field"],
+ "kind": row.get("kind"),
+ "envelope": {
+ "ciphertext": envelope.ciphertext,
+ "nonce": envelope.nonce,
+ "wrap_meta": envelope.wrap_meta,
+ },
+ }
+ )
+ return materials
+
+
def _member_version(row: dict[str, Any]) -> dict[str, Any]:
return {
"name": row["name"],
@@ -1037,13 +1280,25 @@ def _unique_grant_release_refs(rows: list[dict[str, Any]]) -> list[dict[str, str
return refs
+def _field_metadata(row: dict[str, Any]) -> dict[str, Any]:
+ default_field = _default_field_name(row)
+ payload = {"name": str(row["name"]), "kind": str(row.get("kind") or "static"), "default_field": default_field, "fields": [default_field]}
+ try:
+ payload["fields"].extend(item["name"] for item in _extra_field_rows(row, strict=True))
+ except FieldsCorruptError:
+ payload["fields_state"] = "corrupt"
+ return payload
+
+
def _hydrate_card_unlock_material(conn: Connection, row: dict[str, Any], card: dict[str, Any]) -> dict[str, Any]:
card = dict(card)
secret_name = row.get("secret_name")
if secret_name:
secret_row = conn.execute(select(vault_secrets).where(vault_secrets.c.name == secret_name)).mappings().first()
- if secret_row is not None and (material := _protected_unlock_material(dict(secret_row))) is not None:
- card["secret_unlock_material"] = material
+ if secret_row is not None:
+ material = _protected_unlock_material(dict(secret_row))
+ if material is not None:
+ card["secret_unlock_material"] = material
hydrated_options: list[dict[str, Any]] = []
for option in card.get("grant_options") or []:
if not isinstance(option, dict):
@@ -1057,15 +1312,24 @@ def _hydrate_card_unlock_material(conn: Connection, row: dict[str, Any], card: d
current["name"]: dict(current)
for current in conn.execute(select(vault_secrets).where(vault_secrets.c.name.in_(names))).mappings()
}
+ snapshots = {
+ str(item["name"]): item for item in option_payload.get("member_fields") or []
+ if isinstance(item, dict) and isinstance(item.get("name"), str)
+ }
+ # Labels are display metadata, not the frozen authorization member set.
+ # In particular, a default rename deliberately preserves this request.
+ option_payload["member_fields"] = [
+ _field_metadata(current_rows[name]) if name in current_rows else snapshots[name]
+ for name in option_payload.get("member_snapshot") or names
+ if name in current_rows or name in snapshots
+ ]
for version in versions:
if not isinstance(version, dict):
continue
current = current_rows.get(version.get("name"))
if current is None or not _member_version_matches(current, version):
continue
- material = _protected_unlock_material(current)
- if material is not None:
- materials.append(material)
+ materials.extend(_protected_unlock_material_records(current))
if materials:
option_payload["unlock_material"] = materials
hydrated_options.append(option_payload)
@@ -1414,6 +1678,30 @@ def _request_callback_disabled(row: dict[str, Any]) -> bool:
return bool(isinstance(requester, dict) and requester.get("callback_disabled"))
+def has_named_field_shape(metadata: dict[str, Any]) -> bool:
+ """Whether provision guidance needs a field-aware hint instead of legacy NAME."""
+ if str(metadata.get("kind") or "static") == "keypair":
+ return False
+ default_field = str(metadata.get("default_field") or "value")
+ fields = list(metadata.get("fields") or [default_field])
+ return metadata.get("fields_state") == "corrupt" or fields != ["value"] or default_field != "value"
+
+
+def provision_field_hint(metadata: dict[str, Any]) -> str:
+ """Value-free current-field usage shared by synchronous and async provision replies."""
+ name = str(metadata["name"])
+ fields = list(metadata.get("fields") or [metadata.get("default_field") or "value"])
+ default_field = str(metadata.get("default_field") or fields[0])
+ labels = ", ".join(str(field) for field in fields)
+ usage = (
+ f" Current fields: {labels}. Default alias: `{name}.{default_field}`."
+ f" Select a field with `vibe vault run --env {name}.{fields[-1]} -- <command>`."
+ )
+ if metadata.get("fields_state") == "corrupt":
+ return usage + " Extra fields are unavailable because their stored metadata is corrupt."
+ return usage + " Tag and skill selectors deliver every field."
+
+
def _build_request_callback_message(row: dict[str, Any]) -> str:
"""Agent-facing text delivered to the requesting session when a request resolves."""
request_type = str(row.get("request_type") or "")
@@ -1430,6 +1718,9 @@ def _build_request_callback_message(row: dict[str, Any]) -> str:
if status in {"approved", "fulfilled"}:
if request_type == "provision":
usage = f" You can use it, e.g. `vibe vault run --env {name} -- <command>`." if name else ""
+ current = row.get("provision_secret")
+ if name and isinstance(current, dict) and has_named_field_shape(current):
+ usage = provision_field_hint(current)
return f"The user provided your {subject}; the secret is now available.{usage} Continue the task."
if request_type == "access":
return f"The user approved your {subject}; the grant is ready. Continue the task."
@@ -1577,8 +1868,22 @@ def list_pending_request_callbacks(
query = query.order_by(vault_requests.c.decided_at, vault_requests.c.id)
if limit is not None:
query = query.limit(limit)
- rows = conn.execute(query).mappings()
- return [dict(row) for row in rows]
+ rows = [dict(row) for row in conn.execute(query).mappings()]
+ for row in rows:
+ if row.get("request_type") != "provision" or row.get("status") != "fulfilled":
+ continue
+ # Transient callback projection: use the user's actual current fields,
+ # never the requested hints and never any envelope/value material.
+ secret = conn.execute(
+ select(vault_secrets.c.name, vault_secrets.c.kind, vault_secrets.c.id,
+ vault_secrets.c.public_meta, vault_secrets.c.fields, vault_secrets.c.updated_at)
+ .where(vault_secrets.c.name == row.get("secret_name"))
+ ).mappings().first()
+ if secret is not None:
+ current = _field_metadata(dict(secret))
+ if has_named_field_shape(current):
+ row["provision_secret"] = current
+ return rows
def mark_request_callback(conn: Connection, request_id: str, *, status: str) -> None:
@@ -2368,6 +2673,8 @@ def create_secret(
source: str = "manual",
policy: dict[str, Any] | None = None,
public_meta: dict[str, Any] | None = None,
+ fields: list[dict[str, Any]] | None = None,
+ default_field: str | None = None,
establishing_vmk: bool = False,
authz_factor_registration: dict[str, Any] | None = None,
authz_factor_origin: str | None = None,
@@ -2436,6 +2743,42 @@ def create_secret(
public_meta = dict(public_meta or {})
if description:
public_meta["description"] = description
+ if kind == "keypair" and (fields or default_field is not None or "default_field" in public_meta):
+ raise FieldsNotSupportedError("keypair secrets do not support fields or default_field")
+ normalized_default_field = _default_field_name(value=default_field or public_meta.get("default_field"))
+ if default_field is not None:
+ _validate_field_name(default_field, field="default_field")
+ raw_fields = [] if fields is None else fields
+ if not isinstance(raw_fields, list):
+ raise VaultServiceError("fields must be an array")
+ if len(raw_fields) + 1 > MAX_SECRET_FIELDS:
+ raise TooManyFieldsError(f"a vault secret can have at most {MAX_SECRET_FIELDS} fields")
+ stored_fields: list[dict[str, Any]] = []
+ field_names_seen: set[str] = {normalized_default_field}
+ for raw_field in raw_fields:
+ if not isinstance(raw_field, dict):
+ raise VaultServiceError("fields entries must be objects")
+ field_name = _validate_field_name(raw_field.get("name"), field="field name")
+ if field_name in field_names_seen:
+ raise FieldExistsError(f"field {field_name!r} already exists on {name}")
+ if raw_field.get("record", f"{name}.{field_name}") != f"{name}.{field_name}":
+ raise RecordMismatchError(f"record does not match field {field_name!r} on {name}")
+ envelope = raw_field.get("sealed") or raw_field.get("envelope")
+ if not isinstance(envelope, Sealed):
+ raise VaultServiceError("fields entries require sealed envelopes")
+ field_names_seen.add(field_name)
+ stored_fields.append({
+ "name": field_name,
+ "ciphertext": envelope.ciphertext,
+ "nonce": envelope.nonce,
+ "wrap_meta": envelope.wrap_meta,
+ "created_at": now,
+ "updated_at": now,
+ })
+ if normalized_default_field == "value":
+ public_meta.pop("default_field", None)
+ else:
+ public_meta["default_field"] = normalized_default_field
try:
conn.execute(
vault_secrets.insert().values(
@@ -2449,6 +2792,7 @@ def create_secret(
ciphertext=sealed.ciphertext,
nonce=sealed.nonce,
wrap_meta=sealed.wrap_meta,
+ fields=json.dumps(stored_fields) if stored_fields else None,
public_meta=json.dumps(public_meta) if public_meta else None,
policy=json.dumps(policy) if policy else None,
use_count=0,
@@ -2534,6 +2878,7 @@ def update_secret_metadata(
description: Any = _UNSET,
tags: Any = _UNSET,
policy: Any = _UNSET,
+ default_field: Any = _UNSET,
cache: VaultGrantRuntimeCache = GRANT_RUNTIME_CACHE,
release_scopes: list[dict[str, str]] | None = None,
user_context: Any = None,
@@ -2549,6 +2894,8 @@ def update_secret_metadata(
row = _require_secret_resource_management(conn, _require_row(conn, secret_name), context)
values: dict[str, Any] = {}
fields: list[str] = []
+ public_meta: dict[str, Any] | None = None
+ policy_changed = False
if description is not _UNSET:
public_meta = _public_meta(row.get("public_meta"))
@@ -2557,7 +2904,6 @@ def update_secret_metadata(
public_meta["description"] = normalized_description
else:
public_meta.pop("description", None)
- values["public_meta"] = json.dumps(public_meta) if public_meta else None
fields.append("description")
if tags is not _UNSET:
@@ -2565,6 +2911,23 @@ def update_secret_metadata(
values["tags"] = json.dumps(normalized_tags) if normalized_tags else None
fields.append("tags")
+ if default_field is not _UNSET:
+ if row.get("kind") == "keypair":
+ raise FieldsNotSupportedError("keypair secrets do not support default_field")
+ normalized_default = _validate_field_name(default_field, field="default_field")
+ extras = _extra_field_rows(row, strict=True)
+ existing_default = _default_field_name(row)
+ if normalized_default != existing_default:
+ if normalized_default in {str(item["name"]) for item in extras}:
+ raise FieldExistsError(f"field {normalized_default!r} already exists on {secret_name}")
+ if public_meta is None:
+ public_meta = _public_meta(row.get("public_meta"))
+ if normalized_default == "value":
+ public_meta.pop("default_field", None)
+ else:
+ public_meta["default_field"] = normalized_default
+ fields.append("default_field")
+
if policy is not _UNSET:
if policy is None:
policy = {}
@@ -2592,16 +2955,34 @@ def update_secret_metadata(
values["policy"] = json.dumps(next_policy) if next_policy else None
fields.append("policy")
if normalized_policy != existing_visible_policy:
- grant_rows = active_grant_rows_for_secret(conn, secret_name)
- _expire_pending_requests_for_secret(conn, secret_name, reason="request-expired-policy-changed")
- _expire_grant_rows(conn, grant_rows, cache=cache, reason="grant-expired-policy-changed")
- if release_scopes is not None:
- release_scopes.extend(agent_release_scopes_after_rows(conn, grant_rows, cache=cache))
+ policy_changed = True
+
+ if public_meta is not None:
+ values["public_meta"] = json.dumps(public_meta) if public_meta else None
if not values:
return _meta_payload(row)
- conn.execute(vault_secrets.update().where(vault_secrets.c.name == secret_name).values(**values))
+ # Display metadata does not change the envelopes or their approval versions.
+ # Compare the written columns as well, since those edits share that version.
+ compared_columns = list(values)
+ result = conn.execute(
+ vault_secrets.update()
+ .where(
+ vault_secrets.c.id == row["id"],
+ vault_secrets.c.updated_at == row["updated_at"],
+ *(vault_secrets.c[key] == row.get(key) for key in compared_columns),
+ )
+ .values(**values)
+ )
+ if result.rowcount != 1:
+ raise SecretConflictError(f"secret {secret_name!r} changed while metadata was being updated")
+ if policy_changed:
+ policy_grant_rows = active_grant_rows_for_secret(conn, secret_name)
+ _expire_pending_requests_for_secret(conn, secret_name, reason="request-expired-policy-changed")
+ _expire_grant_rows(conn, policy_grant_rows, cache=cache, reason="grant-expired-policy-changed")
+ if release_scopes is not None:
+ release_scopes.extend(agent_release_scopes_after_rows(conn, policy_grant_rows, cache=cache))
audit(conn, "metadata-updated", secret_name=secret_name, delivery={"fields": fields})
return _meta_payload(_require_row(conn, secret_name))
@@ -2687,11 +3068,17 @@ def store_pubkey_pin(
for key, value in pin.items()
if key in {"public_key", "fingerprint", "attested_at", "attestation"}
}
- conn.execute(
+ result = conn.execute(
vault_secrets.update()
- .where(vault_secrets.c.name == name)
+ .where(
+ vault_secrets.c.id == row["id"],
+ vault_secrets.c.updated_at == row["updated_at"],
+ vault_secrets.c.public_meta == row.get("public_meta"),
+ )
.values(public_meta=json.dumps(public_meta))
)
+ if result.rowcount != 1:
+ raise SecretConflictError(f"secret {name!r} changed while metadata was being updated")
audit(
conn,
"pubkey_pinned",
@@ -2723,6 +3110,10 @@ def _searchable_secret_text(secret: dict[str, Any]) -> str:
secret.get("signer_kind"),
secret.get("description"),
secret.get("tags"),
+ secret.get("default_field"),
+ secret.get("fields"),
+ secret_record_names(secret),
+ f"{secret.get('name')}.{secret.get('default_field') or 'value'}",
]
policy = secret.get("policy")
if isinstance(policy, dict):
@@ -2841,25 +3232,162 @@ def rotate_secret(
) -> dict[str, Any]:
context = resolve_resource_access_context(user_context)
row = _require_secret_resource_management(conn, _require_row(conn, name), context)
+ _extra_field_rows(row, strict=True)
public_meta = _public_meta(row.get("public_meta"))
public_meta.pop("preview", None)
- _expire_pending_requests_for_secret(conn, name, reason="request-expired-envelope-changed")
- _expire_active_grants_for_secret(conn, name, cache=cache, reason="grant-expired-envelope-changed")
- conn.execute(
+ result = conn.execute(
vault_secrets.update()
- .where(vault_secrets.c.name == name)
+ .where(
+ vault_secrets.c.id == row["id"],
+ vault_secrets.c.updated_at == row["updated_at"],
+ vault_secrets.c.public_meta == row.get("public_meta"),
+ )
.values(
ciphertext=sealed.ciphertext,
nonce=sealed.nonce,
wrap_meta=sealed.wrap_meta,
public_meta=json.dumps(public_meta) if public_meta else None,
- updated_at=_now(),
+ updated_at=_next_updated_at(str(row.get("updated_at") or "")),
)
)
+ if result.rowcount != 1:
+ raise SecretConflictError(f"secret {name!r} changed while its value was being updated")
+ _expire_pending_requests_for_secret(conn, name, reason="request-expired-envelope-changed")
+ _expire_active_grants_for_secret(conn, name, cache=cache, reason="grant-expired-envelope-changed")
audit(conn, "updated", secret_name=name)
return _meta_payload(_require_row(conn, name))
+def _expire_envelope_change(
+ conn: Connection,
+ secret_name: str,
+ *,
+ cache: VaultGrantRuntimeCache = GRANT_RUNTIME_CACHE,
+ release_scopes: list[dict[str, str]] | None = None,
+) -> None:
+ _expire_pending_requests_for_secret(conn, secret_name, reason="request-expired-envelope-changed")
+ grant_rows = active_grant_rows_for_secret(conn, secret_name)
+ _expire_grant_rows(conn, grant_rows, cache=cache, reason="grant-expired-envelope-changed")
+ if release_scopes is not None:
+ release_scopes.extend(agent_release_scopes_after_rows(conn, grant_rows, cache=cache))
+
+
+def _stored_fields_json(fields: list[dict[str, Any]]) -> str | None:
+ return json.dumps(fields) if fields else None
+
+
+def _require_field_record(row: dict[str, Any], field_name: str, record: str) -> None:
+ expected = record_name_for_field(str(row["name"]), field_name, default_field=_default_field_name(row))
+ if record != expected:
+ raise RecordMismatchError(f"record does not match field {field_name!r} on {row['name']}")
+
+
+def update_secret_field(
+ conn: Connection,
+ secret_name: str,
+ field_name: str,
+ sealed: Sealed,
+ *,
+ record: str,
+ expected_updated_at: str | None = None,
+ cache: VaultGrantRuntimeCache = GRANT_RUNTIME_CACHE,
+ release_scopes: list[dict[str, str]] | None = None,
+ user_context: Any = None,
+) -> dict[str, Any]:
+ context = resolve_resource_access_context(user_context)
+ row = _require_secret_resource_management(conn, _require_row(conn, secret_name), context)
+ field_name = _validate_field_name(field_name)
+ snapshot_updated_at = row.get("updated_at")
+ if expected_updated_at is not None and snapshot_updated_at != expected_updated_at:
+ raise SecretConflictError(f"secret {secret_name!r} changed while the field was being updated")
+ if row.get("kind") == "keypair":
+ raise FieldsNotSupportedError(f"{secret_name} does not support fields")
+ _require_field_record(row, field_name, record)
+ default_field = _default_field_name(row)
+ extras = _extra_field_rows(row, strict=True)
+ extra_by_name = {str(item["name"]): item for item in extras}
+ now = _next_updated_at(snapshot_updated_at)
+ if field_name == default_field:
+ values = {"ciphertext": sealed.ciphertext, "nonce": sealed.nonce, "wrap_meta": sealed.wrap_meta}
+ op = "replace"
+ else:
+ existing = extra_by_name.get(field_name)
+ if existing is None:
+ if len(extras) + 1 >= MAX_SECRET_FIELDS:
+ raise TooManyFieldsError(f"a vault secret can have at most {MAX_SECRET_FIELDS} fields")
+ extras.append({
+ "name": field_name,
+ "ciphertext": sealed.ciphertext,
+ "nonce": sealed.nonce,
+ "wrap_meta": sealed.wrap_meta,
+ "created_at": now,
+ "updated_at": now,
+ })
+ op = "add"
+ else:
+ existing.update({"ciphertext": sealed.ciphertext, "nonce": sealed.nonce, "wrap_meta": sealed.wrap_meta, "updated_at": now})
+ op = "replace"
+ values = {"fields": _stored_fields_json(extras)}
+ values["updated_at"] = now
+ stmt = vault_secrets.update().where(
+ vault_secrets.c.id == row["id"],
+ vault_secrets.c.updated_at == snapshot_updated_at,
+ vault_secrets.c.public_meta == row.get("public_meta"),
+ )
+ result = conn.execute(stmt.values(**values))
+ if result.rowcount != 1:
+ # A rename can race this transaction after its initial read without
+ # changing updated_at. Never store an envelope under the wrong record.
+ current = _require_row(conn, secret_name)
+ if current.get("id") == row.get("id"):
+ _require_field_record(current, field_name, record)
+ raise SecretConflictError(f"secret {secret_name!r} changed while the field was being updated")
+ _expire_envelope_change(conn, secret_name, cache=cache, release_scopes=release_scopes)
+ audit(conn, "updated", secret_name=secret_name, delivery={"field": field_name, "op": op})
+ return _meta_payload(_require_row(conn, secret_name))
+
+
+def remove_secret_field(
+ conn: Connection,
+ secret_name: str,
+ field_name: str,
+ *,
+ expected_updated_at: str | None = None,
+ cache: VaultGrantRuntimeCache = GRANT_RUNTIME_CACHE,
+ release_scopes: list[dict[str, str]] | None = None,
+ user_context: Any = None,
+) -> dict[str, Any]:
+ context = resolve_resource_access_context(user_context)
+ row = _require_secret_resource_management(conn, _require_row(conn, secret_name), context)
+ field_name = _validate_field_name(field_name)
+ snapshot_updated_at = row.get("updated_at")
+ if expected_updated_at is not None and snapshot_updated_at != expected_updated_at:
+ raise SecretConflictError(f"secret {secret_name!r} changed while the field was being removed")
+ if row.get("kind") == "keypair":
+ raise FieldsNotSupportedError(f"{secret_name} does not support fields")
+ if field_name == _default_field_name(row):
+ raise InvalidRequestError("the default field cannot be removed")
+ extras = _extra_field_rows(row, strict=True)
+ if not any(str(item["name"]) == field_name for item in extras):
+ raise FieldNotFoundError(f"field {field_name!r} not found on {secret_name}; fields: {', '.join(secret_field_names(row))}")
+ extras = [item for item in extras if str(item["name"]) != field_name]
+ stmt = vault_secrets.update().where(
+ vault_secrets.c.id == row["id"],
+ vault_secrets.c.updated_at == snapshot_updated_at,
+ )
+ result = conn.execute(
+ stmt.values(
+ fields=_stored_fields_json(extras),
+ updated_at=_next_updated_at(str(snapshot_updated_at or "")),
+ )
+ )
+ if result.rowcount != 1:
+ raise SecretConflictError(f"secret {secret_name!r} changed while the field was being removed")
+ _expire_envelope_change(conn, secret_name, cache=cache, release_scopes=release_scopes)
+ audit(conn, "updated", secret_name=secret_name, delivery={"field": field_name, "op": "remove"})
+ return _meta_payload(_require_row(conn, secret_name))
+
+
def _disable_webauthn_factors_if_vault_deestablished(conn: Connection) -> None:
protected_row = conn.execute(
select(vault_secrets.c.id).where(vault_secrets.c.protection == "protected").limit(1)
@@ -2900,51 +3428,41 @@ def delete_secret(
def get_secret_policy(conn: Connection, name: str, *, user_context: Any = None) -> dict[str, Any]:
"""Return the secret's non-secret policy dict (allowed_hosts, auth scheme)."""
- return _loads(require_secret_access(conn, name, user_context=user_context).get("policy")) or {}
+ row, _entry = _resolve_record_ref(conn, name, user_context=user_context)
+ return _loads(row.get("policy")) or {}
def get_envelope(conn: Connection, name: str, *, user_context: Any = None) -> Sealed:
- """Return one standard-tier secret's stored envelope (no decrypt, no audit).
-
- For the brokered ``fetch`` proxy: the caller hands the envelope to the avault
- client (which decrypts + delivers), then records its own ``record_proxy_use``.
- Validate any policy (e.g. host allowlist) *before* delivering.
-
- Protected delivery must go through :func:`resolve_secret_access` and the
- resident avault agent so Python never opens released DEKs or plaintext.
- """
- row = require_secret_access(conn, name, user_context=user_context)
+ """Return one standard-tier record envelope for ``NAME`` or ``NAME.field``."""
+ row, entry = _resolve_record_ref(conn, name, user_context=user_context)
if row.get("protection") != "standard":
raise UnsupportedProtectionError(f"{name} is protected-tier; use resident-agent grant delivery")
- _reject_keypair_value_delivery(row, name)
- return _row_sealed(row)
+ _reject_keypair_value_delivery(row, str(row["name"]))
+ return entry["envelope"]
def get_protected_envelope(conn: Connection, name: str, *, user_context: Any = None) -> Sealed:
- row = require_secret_access(conn, name, user_context=user_context)
+ row, entry = _resolve_record_ref(conn, name, user_context=user_context)
if row.get("protection") != "protected":
raise UnsupportedProtectionError(f"{name} is standard-tier")
- _reject_keypair_value_delivery(row, name)
- return _row_sealed(row)
+ _reject_keypair_value_delivery(row, str(row["name"]))
+ return entry["envelope"]
def get_protected_record_envelope(conn: Connection, name: str, *, user_context: Any = None) -> Sealed:
- row = require_secret_access(conn, name, user_context=user_context)
- if row.get("protection") != "protected":
- raise UnsupportedProtectionError(f"{name} is standard-tier")
- _reject_keypair_value_delivery(row, name)
- return _row_sealed(row)
+ return get_protected_envelope(conn, name, user_context=user_context)
-def record_proxy_use(conn: Connection, name: str, *, requester: Any = None, delivery: Any = None) -> None:
- """Bump usage + write a value-free ``proxied`` audit row after a brokered request."""
- row = _require_row(conn, name)
+def record_proxy_use(conn: Connection, identity: DeliveryIdentity, *, requester: Any = None, delivery: Any = None) -> None:
+ """Record an actual egress from its pre-handoff identity, even after deletion."""
conn.execute(
vault_secrets.update()
- .where(vault_secrets.c.name == name)
+ .where(vault_secrets.c.id == identity.secret_id)
.values(last_used_at=_now(), use_count=vault_secrets.c.use_count + 1)
)
- audit(conn, "proxied", secret_name=name, requester=requester, delivery=delivery)
+ delivery_payload = dict(delivery) if isinstance(delivery, dict) else {}
+ delivery_payload["field"] = identity.field
+ audit(conn, "proxied", secret_name=identity.name, requester=requester, delivery=delivery_payload, access_snapshot=identity.access_snapshot)
def record_signing_use(
@@ -2974,13 +3492,23 @@ def record_reveal_use(
request_id: str | None = None,
) -> None:
"""Bump revealed secret usage + write a value-free ``revealed`` audit row."""
- _require_row(conn, name)
+ row, entry = _resolve_record_ref(conn, name)
+ secret_name = str(row["name"])
conn.execute(
vault_secrets.update()
- .where(vault_secrets.c.name == name)
+ .where(vault_secrets.c.name == secret_name)
.values(last_used_at=_now(), use_count=vault_secrets.c.use_count + 1)
)
- audit(conn, "revealed", secret_name=name, requester=requester, delivery=delivery, request_id=request_id)
+ delivery_payload = dict(delivery) if isinstance(delivery, dict) else {}
+ delivery_payload["field"] = str(entry["field"])
+ audit(
+ conn,
+ "revealed",
+ secret_name=secret_name,
+ requester=requester,
+ delivery=delivery_payload,
+ request_id=request_id,
+ )
def get_envelopes(conn: Connection, names: list[str], *, user_context: Any = None) -> dict[str, Sealed]:
@@ -2994,12 +3522,12 @@ def get_envelopes(conn: Connection, names: list[str], *, user_context: Any = Non
"""
context = resolve_resource_access_context(user_context)
out: dict[str, Sealed] = {}
- for name in names:
- row = _require_secret_resource_access(conn, _require_row(conn, name), context)
+ for ref in names:
+ row, entry = _resolve_record_ref(conn, ref, user_context=context)
if row.get("protection") != "standard":
- raise UnsupportedProtectionError(f"{name} is protected-tier; use resident-agent grant delivery")
- _reject_keypair_value_delivery(row, name)
- out[name] = _row_sealed(row)
+ raise UnsupportedProtectionError(f"{ref} is protected-tier; use resident-agent grant delivery")
+ _reject_keypair_value_delivery(row, str(row["name"]))
+ out[str(entry["name"])] = entry["envelope"]
return out
@@ -3024,19 +3552,40 @@ def get_signing_envelope(conn: Connection, name: str, *, user_context: Any = Non
return get_key_envelope(conn, name, user_context=user_context)
-def record_deliveries(conn: Connection, names: list[str], *, requester: Any = None, mode: str | None = None) -> None:
- """Bump usage + write a value-free ``delivered`` audit row per name.
-
- Call this only AFTER the delivery action (child spawn / file write / stream) succeeds,
- so the audit trail and usage counts never record a delivery that didn't happen.
- """
- for name in names:
+def capture_delivery_identities(conn: Connection, refs: list[str], *, user_context: Any = None) -> list[DeliveryIdentity]:
+ """Capture labels and ACL identity while the selected records still exist."""
+ identities: list[DeliveryIdentity] = []
+ snapshots: dict[str, dict[str, Any] | None] = {}
+ for ref in refs:
+ row, entry = _resolve_record_ref(conn, ref, user_context=user_context)
+ name = str(row["name"])
+ if name not in snapshots:
+ snapshots[name] = _build_audit_access_snapshot(conn, [name])
+ identities.append(DeliveryIdentity(str(row["id"]), name, str(entry["field"]), snapshots[name]))
+ return identities
+
+
+def record_deliveries(conn: Connection, identities: list[DeliveryIdentity], *, requester: Any = None, mode: str | None = None) -> None:
+ """Bookkeep a completed handoff without resolving records a second time."""
+ delivered: dict[str, tuple[DeliveryIdentity, list[str]]] = {}
+ for identity in identities:
+ _, fields = delivered.setdefault(identity.secret_id, (identity, []))
+ if identity.field not in fields:
+ fields.append(identity.field)
+ for identity, fields in delivered.values():
conn.execute(
vault_secrets.update()
- .where(vault_secrets.c.name == name)
+ .where(vault_secrets.c.id == identity.secret_id)
.values(last_used_at=_now(), use_count=vault_secrets.c.use_count + 1)
)
- audit(conn, "delivered", secret_name=name, requester=requester, delivery={"mode": mode})
+ audit(
+ conn,
+ "delivered",
+ secret_name=identity.name,
+ requester=requester,
+ delivery={"mode": mode, "fields": fields},
+ access_snapshot=identity.access_snapshot,
+ )
def _active_session_turn_anchor(
@@ -3219,14 +3768,20 @@ def _parse_env_selector(spec: str) -> tuple[str, str]:
if not raw:
raise InvalidRequestError("env selector must be non-empty")
if "=" in raw:
- env_name, secret_name = raw.split("=", 1)
+ env_name, record_ref = raw.split("=", 1)
env_name = env_name.strip()
- secret_name = secret_name.strip()
+ record_ref = record_ref.strip()
+ if not env_name:
+ raise InvalidRequestError("env selector alias must be non-empty")
else:
- env_name = secret_name = raw
- if not _is_delivery_env_name(env_name) or not vault_crypto.is_valid_secret_name(secret_name):
+ record_ref = raw
+ base, separator, field = record_ref.partition(".")
+ env_name = base if not separator else f"{base}_{field.upper()}"
+ if not _is_delivery_env_name(env_name):
+ raise InvalidRequestError("env selector must use a valid env alias and secret name")
+ if not vault_crypto.is_valid_secret_name(record_ref.split(".", 1)[0]):
raise InvalidRequestError("env selector must use a valid env alias and secret name")
- return env_name, secret_name
+ return env_name, record_ref
def _is_delivery_env_name(name: str) -> bool:
@@ -3247,26 +3802,29 @@ def expand_value_delivery_selector(
selector = _source_selector_payload(source_selector or {"env": env or [], "tags": tags or [], "skills": skills or []})
context = resolve_resource_access_context(user_context)
selections: list[dict[str, Any]] = []
- env_by_secret: dict[str, str] = {}
- secret_by_env: dict[str, str] = {}
+ env_by_record: dict[str, str] = {}
+ record_by_env: dict[str, str] = {}
- def add_selection(row: dict[str, Any], env_name: str) -> None:
+ def add_selection(row: dict[str, Any], entry: dict[str, Any], env_name: str) -> None:
_require_secret_resource_access(conn, row, context)
secret_name = str(row["name"])
_reject_keypair_value_delivery(row, secret_name)
- existing_env = env_by_secret.get(secret_name)
+ record = str(entry["name"])
+ existing_env = env_by_record.get(record)
if existing_env is not None:
if existing_env != env_name:
- raise InvalidRequestError(f"{secret_name} was selected with conflicting env names")
+ raise InvalidRequestError(f"{record} was selected with conflicting env names")
return
- existing_secret = secret_by_env.get(env_name)
- if existing_secret is not None and existing_secret != secret_name:
- raise InvalidRequestError(f"env {env_name} maps to multiple vault secrets")
- env_by_secret[secret_name] = env_name
- secret_by_env[env_name] = secret_name
+ existing_record = record_by_env.get(env_name)
+ if existing_record is not None and existing_record != record:
+ raise InvalidRequestError(f"env {env_name} maps to multiple vault records")
+ env_by_record[record] = env_name
+ record_by_env[env_name] = record
selections.append(
{
"name": secret_name,
+ "field": str(entry["field"]),
+ "record": record,
"env": env_name,
"kind": row.get("kind"),
"protection": row.get("protection"),
@@ -3274,8 +3832,9 @@ def expand_value_delivery_selector(
)
for env_spec in selector.get("env") or []:
- env_name, secret_name = _parse_env_selector(str(env_spec))
- add_selection(_require_row(conn, secret_name), env_name)
+ env_name, record_ref = _parse_env_selector(str(env_spec))
+ row, entry = _resolve_record_ref(conn, record_ref, user_context=context)
+ add_selection(row, entry, env_name)
for tag in selector.get("tags") or []:
normalized = _normalize_tag(str(tag))
@@ -3285,7 +3844,11 @@ def expand_value_delivery_selector(
if normalized in _row_tags(dict(row))
]
for row in rows:
- add_selection(row, str(row["name"]))
+ _require_secret_resource_access(conn, row, context)
+ for entry in _record_entries(row, strict=True):
+ field = str(entry["field"])
+ env_name = str(row["name"]) if entry["name"] == row["name"] else f"{row['name']}_{field.upper()}"
+ add_selection(row, entry, env_name)
return {"source_selector": selector, "secrets": selections}
@@ -3298,8 +3861,13 @@ def _request_member_rows_for_selector(
) -> list[dict[str, Any]]:
expanded = expand_value_delivery_selector(conn, source_selector=source_selector, user_context=user_context)
rows: list[dict[str, Any]] = []
+ seen_names: set[str] = set()
for item in expanded["secrets"]:
- row = _require_row(conn, str(item["name"]))
+ secret_name = str(item["name"])
+ if secret_name in seen_names:
+ continue
+ seen_names.add(secret_name)
+ row = _require_row(conn, secret_name)
if row.get("protection") == "protected" or _secret_always_ask(row):
rows.append(row)
return rows
@@ -3404,6 +3972,7 @@ def _grant_option(
"member_count": len(members),
"member_snapshot": members,
"member_versions": [_member_version(row) for row in rows],
+ "member_fields": [_field_metadata(row) for row in rows],
}
if one_shot:
option["one_shot"] = True
@@ -3486,7 +4055,8 @@ def create_access_request(
if protected_delivery_names:
rows = _filter_request_rows_to_protected_names(rows, protected_delivery_names)
if name:
- direct_row = _require_secret_resource_access(conn, _require_row(conn, name), context)
+ direct_row, _entry = _resolve_record_ref(conn, name, user_context=context)
+ name = str(direct_row["name"])
if not _secret_access_requestable(direct_row):
raise NotGrantableError(f"{name} is not access-requestable")
if not rows:
@@ -3762,6 +4332,12 @@ def _agent_binding_approval_record_cap(row_dict: dict[str, Any], new_record: dic
members = option.get("member_snapshot")
if isinstance(members, list):
member_count = max(member_count, len([name for name in members if isinstance(name, str) and name]))
+ member_fields = option.get("member_fields")
+ if isinstance(member_fields, list):
+ member_count = max(
+ member_count,
+ sum(len(secret_record_names(meta)) for meta in member_fields if isinstance(meta, dict)),
+ )
return max(1, member_count, len(_agent_binding_record_item_names(new_record)))
@@ -4923,10 +5499,12 @@ def resolve_secret_access(
expire the grant and re-run this resolver to create a fresh approval request.
"""
context = resolve_resource_access_context(user_context)
- row = _require_secret_resource_access(conn, _require_row(conn, name), context)
+ row, record_entry = _resolve_record_ref(conn, name, user_context=context)
+ secret_name = str(row["name"])
+ record_name = str(record_entry["name"])
if purpose not in GRANT_PURPOSES:
raise InvalidRequestError(f"invalid grant purpose: {purpose!r}")
- _reject_keypair_value_delivery(row, name)
+ _reject_keypair_value_delivery(row, secret_name)
delivery_payload = dict(delivery or {})
effective_session_id = (
session_id
@@ -4935,10 +5513,10 @@ def resolve_secret_access(
)
always_ask = _secret_always_ask(row)
if row.get("protection") == "standard" and not always_ask:
- return {"status": "standard", "secret": _meta_payload(row), "envelope": _row_sealed(row)}
+ return {"status": "standard", "secret": _meta_payload(row), "envelope": record_entry["envelope"]}
grant = find_active_grant_for_secret(
conn,
- name,
+ secret_name,
session_id=effective_session_id,
purpose=purpose,
cache=cache,
@@ -4949,7 +5527,7 @@ def resolve_secret_access(
"status": "standard" if row.get("protection") == "standard" else "agent_delivery_ready",
"secret": _meta_payload(row),
"grant": grant,
- "envelope": _row_sealed(row),
+ "envelope": record_entry["envelope"],
"request": None,
}
request_payload = None
@@ -4958,8 +5536,8 @@ def resolve_secret_access(
delivery_payload["session_id"] = effective_session_id
request_payload = create_access_request(
conn,
- name,
- source_selector={"env": [name]},
+ secret_name,
+ source_selector={"env": [record_name]},
purpose=purpose,
requester=requester,
delivery=delivery_payload,
diff --git a/tests/fixtures/member_management_existing_read_roles.json b/tests/fixtures/member_management_existing_read_roles.json
index 739fffec9..4f1dac65c 100644
--- a/tests/fixtures/member_management_existing_read_roles.json
+++ b/tests/fixtures/member_management_existing_read_roles.json
@@ -8,6 +8,7 @@
"DELETE /api/terminal/example": "viewer",
"DELETE /api/vault/grants/example": "editor",
"DELETE /api/vault/secrets/example": "editor",
+ "DELETE /api/vault/secrets/example/fields/example": "editor",
"DELETE /api/web-push/subscriptions": "viewer",
"GET /api/agent-backends": "editor",
"GET /api/agents": "editor",
@@ -137,5 +138,6 @@
"POST /api/web-push/test": "viewer",
"PUT /api/dock/order": "editor",
"PUT /api/files/write": "editor",
- "PUT /api/sessions/example/draft": "editor"
+ "PUT /api/sessions/example/draft": "editor",
+ "PUT /api/vault/secrets/example/fields/example": "editor"
}
diff --git a/tests/test_agent_context_seq_migration.py b/tests/test_agent_context_seq_migration.py
index d1a8234e8..296a914eb 100644
--- a/tests/test_agent_context_seq_migration.py
+++ b/tests/test_agent_context_seq_migration.py
@@ -56,7 +56,7 @@ def test_context_seq_upgrade_and_downgrade_keep_released_rows(tmp_path):
migrations.run_migrations(path)
with sqlite3.connect(path) as conn:
- assert conn.execute("SELECT version_num FROM alembic_version").fetchone() == ("20261012_0064",)
+ assert conn.execute("SELECT version_num FROM alembic_version").fetchone() == ("20261013_0065",)
assert_released_rows_unchanged(conn)
assert _index_sql(conn, "ix_agent_events_turn_sequence_id") is not None
for table, (first, same_session, other_session) in _IDS.items():
diff --git a/tests/test_member_management_parity.py b/tests/test_member_management_parity.py
index e94652d3c..083c065b6 100644
--- a/tests/test_member_management_parity.py
+++ b/tests/test_member_management_parity.py
@@ -118,7 +118,10 @@ def test_complete_registered_api_management_inventory():
for method in (getattr(route, "methods", None) or ())
if method not in {"HEAD", "OPTIONS"}
}
- assert len(endpoints) == 283
+ assert len(endpoints) == 285
+ for method in ("PUT", "DELETE"):
+ assert (method, "/api/vault/secrets/{name}/fields/{field}") in endpoints
+ assert http_authorization_policy(method, "/api/vault/secrets/LOGIN/fields/username").minimum_role == "editor"
assert http_authorization_policy("POST", "/api/desktop-mini/session").minimum_role == "editor"
assert http_authorization_policy("GET", "/api/desktop/capabilities").minimum_role == "member"
assert http_authorization_policy("GET", "/api/desktop/computer-use/status").minimum_role == "member"
diff --git a/tests/test_resource_acl_vaults.py b/tests/test_resource_acl_vaults.py
index bc19fb391..c5df4898e 100644
--- a/tests/test_resource_acl_vaults.py
+++ b/tests/test_resource_acl_vaults.py
@@ -477,6 +477,8 @@ def test_active_org_member_resolves_private_secret_cli_selectors(vault, selector
assert expanded["secrets"] == [
{
"name": "PRIVATE_SELECTOR",
+ "field": "value",
+ "record": "PRIVATE_SELECTOR",
"env": "PRIVATE_SELECTOR",
"kind": "static",
"protection": "standard",
@@ -735,6 +737,10 @@ def test_secret_management_follows_instance_manager_capability(vault, role):
operations = (
lambda: vault_service.update_secret_tags(conn, "MANAGED_KEY", ["test"], user_context=context),
lambda: vault_service.update_secret_metadata(conn, "MANAGED_KEY", description="managed", user_context=context),
+ lambda: vault_service.update_secret_field(conn, "MANAGED_KEY", "username", _sealed("user"), record="MANAGED_KEY.username", user_context=context),
+ lambda: vault_service.update_secret_field(conn, "MANAGED_KEY", "value", _sealed("default"), record="MANAGED_KEY", user_context=context),
+ lambda: vault_service.update_secret_metadata(conn, "MANAGED_KEY", default_field="password", user_context=context),
+ lambda: vault_service.remove_secret_field(conn, "MANAGED_KEY", "username", user_context=context),
lambda: vault_service.update_secret_classification(conn, "MANAGED_KEY", protection="protected", user_context=context),
lambda: vault_service.store_pubkey_pin(conn, "MANAGED_KEY", {"fingerprint": "test-pin"}, user_context=context),
lambda: vault_service.rotate_secret(conn, "MANAGED_KEY", _sealed("rotated"), user_context=context),
diff --git a/tests/test_skill_observability_migration.py b/tests/test_skill_observability_migration.py
index 5f566c2ee..9eb7a510b 100644
--- a/tests/test_skill_observability_migration.py
+++ b/tests/test_skill_observability_migration.py
@@ -35,7 +35,7 @@ def test_skill_schema_upgrade_downgrade_preserves_existing_events(tmp_path):
migrations.run_migrations(path)
with sqlite3.connect(path) as conn:
assert conn.execute(f"SELECT {columns} FROM agent_events ORDER BY id").fetchall() == original
- assert conn.execute("SELECT version_num FROM alembic_version").fetchone() == ("20261012_0064",)
+ assert conn.execute("SELECT version_num FROM alembic_version").fetchone() == ("20261013_0065",)
assert conn.execute("SELECT count(*) FROM skill_usage_daily").fetchone() == (0,)
assert {row[2] for row in conn.execute("PRAGMA foreign_key_list(skill_usage_daily)")} == {
"scopes",
diff --git a/tests/test_sqlite_state_migration.py b/tests/test_sqlite_state_migration.py
index fbd2c5987..92dacdf82 100644
--- a/tests/test_sqlite_state_migration.py
+++ b/tests/test_sqlite_state_migration.py
@@ -38,7 +38,7 @@ from vibe.message_types import build_partial_index_predicate
pytestmark = pytest.mark.no_sqlite_template
-HEAD_REVISION = "20261012_0064"
+HEAD_REVISION = "20261013_0065"
# ``storage.models`` builds a bare ``MetaData()``, so its foreign keys are unnamed and
# Alembic cannot re-emit them when batch mode recreates a table. Every migration that
# rebuilds one therefore passes this convention; the rebuild simulated below has to pass
diff --git a/tests/test_vault_api.py b/tests/test_vault_api.py
index 00aa70713..fbe9029ee 100644
--- a/tests/test_vault_api.py
+++ b/tests/test_vault_api.py
@@ -2105,6 +2105,39 @@ def test_request_vault_access_malformed_selector_returns_vault_api_error():
assert exc.value.status == 409
[email protected]("selector,status,code", [
+ ({"env": ["LOGIN.nope"]}, 404, "field_not_found"),
+ ({"env": ["LOGIN.UPPER"]}, 400, "invalid_field_name"),
+ ({"env": ["KEY.value"]}, 409, "fields_not_supported"),
+ ({"tags": ["broken"]}, 409, "fields_corrupt"),
+])
+def test_access_request_preserves_record_error_codes(selector, status, code):
+ with api._vault_engine().begin() as conn:
+ vault_service.create_secret(conn, name="LOGIN", protection="protected", sealed=_sealed("default"))
+ vault_service.create_secret(conn, name="KEY", kind="keypair", protection="protected", sealed=_sealed("key"))
+ vault_service.create_secret(conn, name="BROKEN", protection="protected", tags=["broken"], sealed=_sealed("broken"))
+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "BROKEN").values(fields="corrupt"))
+ with pytest.raises(api.VaultApiError) as exc:
+ api.request_vault_access({"source_selector": selector})
+ assert (exc.value.status, exc.value.code) == (status, code)
+ with api._vault_engine().connect() as conn:
+ assert list(conn.execute(select(vault_service.vault_requests))) == []
+
+
+def test_direct_access_request_resolves_fields_and_keeps_secret_authorization():
+ with api._vault_engine().begin() as conn:
+ vault_service.create_secret(
+ conn, name="LOGIN", protection="protected", default_field="password", sealed=_sealed("password"),
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ requested = api.request_vault_access({"name": "LOGIN.username"})["request"]
+ assert requested["secret_name"] == "LOGIN"
+ assert requested["card"]["grant_options"][0]["member_snapshot"] == ["LOGIN"]
+ with pytest.raises(api.VaultApiError) as exc:
+ api.request_vault_access({"name": "LOGIN.nope"})
+ assert (exc.value.status, exc.value.code) == (404, "field_not_found")
+
+
def test_request_vault_access_reports_missing_selector_member_name():
with pytest.raises(api.VaultApiError) as exc:
api.request_vault_access({"source_selector": {"env": ["MISSING_KEY"]}, "session_id": "ses_1"})
@@ -4321,3 +4354,397 @@ def test_vault_sign_rejects_malformed_digest_before_request_or_avault(monkeypatc
assert exc.value.code == "invalid_digest"
sign.assert_not_called()
assert api.get_vault_requests()["requests"] == []
+
+
[email protected]("default_field", ["value", "password"])
+def test_keypair_create_rejects_explicit_default_field(monkeypatch, default_field):
+ seal = Mock(return_value=_sealed())
+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)
+ with pytest.raises(api.VaultApiError) as exc:
+ api.create_vault_secret({
+ "name": "KEY", "kind": "keypair", "default_field": default_field,
+ "blind_box": _agent_dek_blindbox(),
+ })
+ assert exc.value.code == "fields_not_supported"
+ seal.assert_not_called()
+ assert api.get_vault_secrets()["secrets"] == []
+
+
+def test_keypair_patch_rejects_default_field_and_keeps_implicit_value():
+ created = api.create_vault_secret({
+ "name": "KEY", "kind": "keypair", "protection": "protected",
+ "sealed": {"ciphertext": "ct-key", "nonce": "n-key", "wrap_meta": "wm-key"},
+ })["secret"]
+ with pytest.raises(api.VaultApiError) as exc:
+ api.update_vault_secret("KEY", {"default_field": "private_key"})
+ assert exc.value.code == "fields_not_supported"
+ current = api.get_vault_secrets()["secrets"][0]
+ assert current["default_field"] == "value"
+ assert current["fields"] == ["value"]
+ assert current["updated_at"] == created["updated_at"]
+
+
+def test_create_vault_secret_seals_each_standard_record_name(monkeypatch):
+ seal = Mock(side_effect=[_sealed("default"), _sealed("username"), _sealed("totp")])
+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)
+
+ result = api.create_vault_secret(
+ {
+ "name": "LOGIN",
+ "default_field": "password",
+ "blind_box": _agent_dek_blindbox("default", "default"),
+ "fields": [
+ {
+ "name": "username",
+ "record": "LOGIN.username",
+ "blind_box": _agent_dek_blindbox("username", "username"),
+ },
+ {
+ "name": "totp",
+ "record": "LOGIN.totp",
+ "blind_box": _agent_dek_blindbox("totp", "totp"),
+ },
+ ],
+ }
+ )
+
+ assert result["secret"]["default_field"] == "password"
+ assert result["secret"]["fields"] == ["password", "username", "totp"]
+ assert [call.args[0] for call in seal.call_args_list] == ["LOGIN", "LOGIN.username", "LOGIN.totp"]
+ with api._vault_engine().connect() as conn:
+ assert vault_service.get_envelope(conn, "LOGIN.username") == _sealed("username")
+ assert vault_service.get_envelope(conn, "LOGIN.totp") == _sealed("totp")
+
+
+def test_vault_field_update_and_default_rename_are_value_free(monkeypatch):
+ seal = Mock(side_effect=[_sealed("default"), _sealed("username")])
+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)
+ api.create_vault_secret(
+ {
+ "name": "LOGIN",
+ "blind_box": _agent_dek_blindbox("default", "default"),
+ }
+ )
+ updated = api.update_vault_secret_field(
+ "LOGIN",
+ "username",
+ {
+ "record": "LOGIN.username",
+ "blind_box": _agent_dek_blindbox("username", "username"),
+ },
+ )
+
+ assert updated["secret"]["fields"] == ["value", "username"]
+ assert [call.args[0] for call in seal.call_args_list] == ["LOGIN", "LOGIN.username"]
+ renamed = api.update_vault_secret("LOGIN", {"default_field": "password"})
+ assert renamed["secret"]["default_field"] == "password"
+ assert renamed["secret"]["fields"] == ["password", "username"]
+
+ with pytest.raises(api.VaultApiError) as exc:
+ api.update_vault_secret_field(
+ "LOGIN",
+ "totp",
+ {
+ "blind_box": _agent_dek_blindbox("totp", "totp"),
+ "value": "plaintext",
+ },
+ )
+ assert exc.value.code == "plaintext_value_rejected"
+ assert [call.args[0] for call in seal.call_args_list] == ["LOGIN", "LOGIN.username"]
+
+
+ ("field", "code"),
+ [
+ ({"name": "username", "blind_box": _agent_dek_blindbox("username", "username")}, "invalid_request"),
+ (
+ {
+ "name": "username",
+ "record": "LOGIN",
+ "blind_box": _agent_dek_blindbox("username", "username"),
+ },
+ "record_mismatch",
+ ),
+ ],
+)
+def test_create_extra_field_requires_matching_record(monkeypatch, field, code):
+ seal = Mock(return_value=_sealed("default"))
+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)
+
+ with pytest.raises(api.VaultApiError) as exc:
+ api.create_vault_secret(
+ {
+ "name": "LOGIN",
+ "blind_box": _agent_dek_blindbox("default", "default"),
+ "fields": [field],
+ }
+ )
+
+ assert exc.value.code == code
+ seal.assert_not_called()
+ assert api.get_vault_secrets()["secrets"] == []
+
+
+def test_protected_field_put_rejects_stale_default_record_after_rename():
+ api.create_vault_secret(
+ {
+ "name": "LOGIN",
+ "protection": "protected",
+ "sealed": {"ciphertext": "ct-old", "nonce": "n-old", "wrap_meta": "wm-old"},
+ }
+ )
+ api.update_vault_secret("LOGIN", {"default_field": "password"})
+
+ with api._vault_engine().connect() as conn:
+ before = vault_service.get_protected_envelope(conn, "LOGIN")
+
+ with pytest.raises(api.VaultApiError) as exc:
+ api.update_vault_secret_field(
+ "LOGIN",
+ "value",
+ {
+ "record": "LOGIN",
+ "sealed": {"ciphertext": "ct-new", "nonce": "n-new", "wrap_meta": "wm-new"},
+ },
+ )
+
+ assert exc.value.code == "record_mismatch"
+ with api._vault_engine().connect() as conn:
+ assert vault_service.get_protected_envelope(conn, "LOGIN") == before
+
+
+def test_protected_field_put_record_guard_survives_concurrent_default_rename(monkeypatch):
+ api.create_vault_secret(
+ {
+ "name": "LOGIN",
+ "protection": "protected",
+ "sealed": {"ciphertext": "ct-old", "nonce": "n-old", "wrap_meta": "wm-old"},
+ }
+ )
+ original_sealed_from_payload = api._sealed_from_payload
+ raced = False
+
+ def seal_then_rename(payload):
+ nonlocal raced
+ sealed = original_sealed_from_payload(payload)
+ if not raced:
+ raced = True
+ with api._vault_engine().begin() as conn:
+ vault_service.update_secret_metadata(conn, "LOGIN", default_field="password")
+ return sealed
+
+ monkeypatch.setattr(api, "_sealed_from_payload", seal_then_rename)
+
+ with pytest.raises(api.VaultApiError) as exc:
+ api.update_vault_secret_field(
+ "LOGIN",
+ "value",
+ {
+ "record": "LOGIN",
+ "sealed": {"ciphertext": "ct-raced", "nonce": "n-raced", "wrap_meta": "wm-raced"},
+ },
+ )
+
+ assert exc.value.code == "record_mismatch"
+ with api._vault_engine().connect() as conn:
+ assert vault_service.get_protected_envelope(conn, "LOGIN") == _sealed("old")
+
+
+def test_protected_reveal_context_uses_field_record_name(monkeypatch):
+ api.create_vault_secret(
+ {
+ "name": "PROTECTED_LOGIN",
+ "protection": "protected",
+ "default_field": "password",
+ "sealed": {"ciphertext": "ct-password", "nonce": "n-password", "wrap_meta": "wm-password"},
+ "fields": [
+ {
+ "name": "username",
+ "record": "PROTECTED_LOGIN.username",
+ "sealed": {"ciphertext": "ct-username", "nonce": "n-username", "wrap_meta": "wm-username"},
+ }
+ ],
+ }
+ )
+
+ result = api.create_vault_reveal_context("PROTECTED_LOGIN", {"field": "username"})
+ context = _verified_signed_context(result["context"])
+
+ assert result["envelope"] == {
+ "ciphertext": "ct-username",
+ "nonce": "n-username",
+ "wrap_meta": "wm-username",
+ }
+ assert context["release"]["name"] == "PROTECTED_LOGIN.username"
+ assert context["display"]["secrets"] == [{"name": "PROTECTED_LOGIN.username", "kind": "static"}]
+
+
+def test_every_web_field_error_code_has_english_and_chinese_translations():
+ codes = api._VAULT_FIELD_ERROR_CODES
+ assert codes and len(codes) == len(set(codes))
+ root = Path(__file__).resolve().parents[1]
+ for language in ("en", "zh"):
+ catalog = json.loads((root / "ui" / "src" / "i18n" / f"{language}.json").read_text(encoding="utf-8"))
+ for code in codes:
+ assert isinstance(catalog["errors"].get(code), str) and catalog["errors"][code].strip(), (language, code)
+
+ # Probe the real translator for every service exception type, rather than a
+ # second manually maintained list of field classes. Only type and message
+ # matter to this boundary; storage-specific constructor data is not read.
+ translated = set()
+ for error_type in vars(vault_service).values():
+ if isinstance(error_type, type) and issubclass(error_type, vault_service.VaultServiceError):
+ error = Exception.__new__(error_type)
+ Exception.__init__(error, "metadata error")
+ translated.add(api._vault_field_service_error(error).code)
+ generic_codes = {"vault_error", "invalid_request", "secret_not_found", "resource_access_forbidden"}
+ assert translated - generic_codes == set(codes)
+
+
+def test_single_agent_binding_maps_corrupt_extra_fields_to_fields_corrupt(monkeypatch):
+ agent_key = Mock(return_value=TEST_AGENT_PUBKEY)
+ monkeypatch.setattr(api, "avault_agent_pubkey", agent_key)
+ api.create_vault_secret({
+ "name": "CORRUPT_BIND", "protection": "protected",
+ "sealed": {"ciphertext": "ct", "nonce": "nonce", "wrap_meta": "wrap"},
+ "fields": [{"name": "username", "record": "CORRUPT_BIND.username", "sealed": {"ciphertext": "ct-u", "nonce": "nonce-u", "wrap_meta": "wrap-u"}}],
+ })
+ request = api.request_vault_access({"name": "CORRUPT_BIND"})["request"]
+ grant_id = request["card"]["grant_options"][0]["grant_id"]
+ with api._vault_engine().begin() as conn:
+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "CORRUPT_BIND").values(fields="invalid"))
+ with pytest.raises(api.VaultApiError) as exc:
+ api.create_vault_agent_binding({"name": "CORRUPT_BIND.username", "request_id": request["id"], "grant_id": grant_id})
+ assert (exc.value.status, exc.value.code) == (409, "fields_corrupt")
+ agent_key.assert_not_called()
+
+
+def test_corrupt_fields_return_stable_error_without_disabling_default_reveal():
+ api.create_vault_secret({
+ "name": "CORRUPT_LOGIN", "protection": "protected",
+ "sealed": {"ciphertext": "ct-default", "nonce": "n-default", "wrap_meta": "wm-default"},
+ })
+ engine = api._vault_engine()
+ damaged = '[{"name":"username","ciphertext":"retain-this-record"}]'
+ with engine.begin() as conn:
+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "CORRUPT_LOGIN").values(fields=damaged))
+ for operation in (
+ lambda: api.update_vault_secret("CORRUPT_LOGIN", {"default_field": "password"}),
+ lambda: api.update_vault_secret_field("CORRUPT_LOGIN", "value", {
+ "record": "CORRUPT_LOGIN",
+ "sealed": {"ciphertext": "ct-new", "nonce": "n-new", "wrap_meta": "wm-new"},
+ }),
+ lambda: api.delete_vault_secret_field("CORRUPT_LOGIN", "username"),
+ lambda: api.create_vault_reveal_context("CORRUPT_LOGIN", {"field": "username"}),
+ ):
+ with pytest.raises(api.VaultApiError) as exc:
+ operation()
+ assert (exc.value.status, exc.value.code) == (409, "fields_corrupt")
+ assert api.create_vault_reveal_context("CORRUPT_LOGIN")["envelope"] == {
+ "ciphertext": "ct-default", "nonce": "n-default", "wrap_meta": "wm-default",
+ }
+ with engine.connect() as conn:
+ assert conn.execute(select(vault_secrets.c.fields).where(vault_secrets.c.name == "CORRUPT_LOGIN")).scalar_one() == damaged
+
+
+def test_store_vault_pubkey_pin_maps_storage_cas_conflict_to_409(monkeypatch):
+ """A CAS conflict is a retryable API response, not an uncaught storage error."""
+ pin = {"public_key": "test-public-key", "fingerprint": "test-fingerprint"}
+ store = Mock(side_effect=vault_service.SecretConflictError("concurrent metadata update"))
+ monkeypatch.setattr(vault_service, "store_pubkey_pin", store)
+ publish = Mock()
+ monkeypatch.setattr(api, "_publish_vaults_updated", publish)
+ with pytest.raises(api.VaultApiError) as exc:
+ api.store_vault_pubkey_pin({"name": "PINNED_KEY", "pin": pin})
+ assert exc.value.status == 409
+ assert exc.value.code == "secret_conflict"
+ assert store.call_args.args[1:] == ("PINNED_KEY", pin)
+ publish.assert_not_called()
+
+
+def test_protected_agent_binding_batch_expands_record_names(monkeypatch):
+ monkeypatch.setattr(api, "_require_avault_grant_delivery_surface", lambda _feature: None)
+ monkeypatch.setattr(api, "avault_agent_pubkey", Mock(return_value=TEST_AGENT_PUBKEY))
+ api.create_vault_secret(
+ {
+ "name": "PROTECTED_LOGIN",
+ "protection": "protected",
+ "default_field": "password",
+ "sealed": {"ciphertext": "ct-password", "nonce": "n-password", "wrap_meta": "wm-password"},
+ "fields": [
+ {
+ "name": "username",
+ "record": "PROTECTED_LOGIN.username",
+ "sealed": {"ciphertext": "ct-username", "nonce": "n-username", "wrap_meta": "wm-username"},
+ }
+ ],
+ }
+ )
+ requested = api.request_vault_access({"name": "PROTECTED_LOGIN", "session_id": "ses_1"})
+
+ result = api.create_vault_agent_bindings_batch({"request_id": requested["request"]["id"], "grant_duration": 300})
+
+ assert [item["name"] for item in result["items"]] == ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]
+ display_names = [item["name"] for item in _verified_signed_context(result["items"][0]["context"])["display"]["secrets"]]
+ assert display_names == ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]
+ for item in result["items"]:
+ context = _verified_signed_context(item["context"])
+ assert context["release"]["operationHash"] == api._agent_deliver_operation_hash(item["name"], 300)
+
+
+def test_create_grant_relays_every_protected_record_and_rejects_missing_dek(monkeypatch, avault_p2):
+ """Protect the grant boundary: every released record must reach avault by canonical name."""
+
+ agent_grant = Mock(return_value={"granted": 3, "ttl_secs": 300})
+ monkeypatch.setattr(api, "avault_agent_grant", agent_grant)
+ api.create_vault_secret(
+ {
+ "name": "PROTECTED_LOGIN",
+ "protection": "protected",
+ "default_field": "password",
+ "sealed": {"ciphertext": "ct-password", "nonce": "n-password", "wrap_meta": "wm-password"},
+ "fields": [
+ {
+ "name": "username",
+ "record": "PROTECTED_LOGIN.username",
+ "sealed": {"ciphertext": "ct-username", "nonce": "n-username", "wrap_meta": "wm-username"},
+ },
+ {
+ "name": "totp",
+ "record": "PROTECTED_LOGIN.totp",
+ "sealed": {"ciphertext": "ct-totp", "nonce": "n-totp", "wrap_meta": "wm-totp"},
+ },
+ ],
+ }
+ )
+ requested = api.request_vault_access({"name": "PROTECTED_LOGIN", "session_id": "ses_1"})
+ issued = _issued_agent_dek_payload(requested["request"]["id"])
+
+ with pytest.raises(api.VaultApiError) as exc:
+ api.create_vault_grant(
+ {
+ "session_id": "ses_1",
+ "request_id": requested["request"]["id"],
+ **issued,
+ "deks": issued["deks"][:-1],
+ }
+ )
+
+ assert exc.value.code == "invalid_grant"
+ agent_grant.assert_not_called()
+
+ created = api.create_vault_grant(
+ {
+ "session_id": "ses_1",
+ "request_id": requested["request"]["id"],
+ **issued,
+ }
+ )
+
+ assert created["grant"]["status"] == "active"
+ assert created["grant"]["member_snapshot"] == ["PROTECTED_LOGIN"]
+ assert [item["name"] for item in agent_grant.call_args.kwargs["deks"]] == [
+ "PROTECTED_LOGIN",
+ "PROTECTED_LOGIN.username",
+ "PROTECTED_LOGIN.totp",
+ ]
diff --git a/tests/test_vault_cli.py b/tests/test_vault_cli.py
index 9bf79d39a..4cabe847d 100644
--- a/tests/test_vault_cli.py
+++ b/tests/test_vault_cli.py
@@ -8,11 +8,12 @@ from __future__ import annotations
import argparse
import io
import json
+import shlex
import shutil
import threading
import time
from pathlib import Path
-from unittest.mock import Mock
+from unittest.mock import MagicMock, Mock
import pytest
from sqlalchemy import select
@@ -157,10 +158,18 @@ def _set_protected_always_ask_grant(name: str, *, session_id: str | None = None,
return _grant_from_request(conn, req, session_id=session_id)
-def _set_tag_grant(names: list[str], *, tag: str = "crypto", session_id: str | None = None) -> dict:
+def _set_tag_grant(
+ names: list[str],
+ *,
+ tag: str = "crypto",
+ session_id: str | None = None,
+ fields: list[dict] | None = None,
+) -> dict:
with cli._open_vault_engine().begin() as conn:
for name in names:
- vault_service.create_secret(conn, name=name, protection="protected", tags=[tag], sealed=_sealed(name.lower()))
+ vault_service.create_secret(
+ conn, name=name, protection="protected", tags=[tag], sealed=_sealed(name.lower()), fields=fields
+ )
req = vault_service.create_access_request(
conn,
source_selector={"tags": [tag]},
@@ -236,6 +245,28 @@ def test_parse_env_specs_rejects_duplicate_secret_alias():
assert exc.value.code == "conflicting_env_alias"
+def test_parse_env_specs_uppercases_only_field_name():
+ assert cli._parse_env_specs(["lowerSecret.username"]) == {
+ "lowerSecret_USERNAME": "lowerSecret.username"
+ }
+
+
+def test_vault_skill_cli_examples_are_parser_backed():
+ skill_path = Path(__file__).parents[1] / "skills" / "use-avibe-vault" / "SKILL.md"
+ examples = [
+ shlex.split(line.strip()[1:-1])
+ for line in skill_path.read_text(encoding="utf-8").splitlines()
+ if line.startswith("`vibe ") and line.rstrip().endswith("`")
+ ]
+
+ assert examples
+ parser = cli.build_parser()
+ for example in examples:
+ assert example[0] == "vibe"
+ parsed = parser.parse_args(example[1:])
+ assert parsed.command == "vault"
+
+
def test_vault_parser_does_not_expose_plaintext_set_command():
parser = cli.build_parser()
with pytest.raises(SystemExit):
@@ -353,6 +384,13 @@ def test_edit_policy_releases_resident_grant(capfd, monkeypatch):
assert status == "expired"
+def test_edit_cas_conflict_preserves_machine_readable_code(capfd, monkeypatch):
+ _create_standard_secret("EDIT_CONFLICT")
+ monkeypatch.setattr(vault_service, "update_secret_metadata", Mock(side_effect=vault_service.SecretConflictError("changed")))
+ assert cli.cmd_vault_edit(_ns(name="EDIT_CONFLICT", description="new")) == 1
+ assert json.loads(capfd.readouterr().err)["code"] == "secret_conflict"
+
+
def test_edit_metadata_json_rejects_secret_material(capfd):
_create_standard_secret("EDIT_SAFE")
@@ -363,6 +401,41 @@ def test_edit_metadata_json_rejects_secret_material(capfd):
assert payload["code"] == "secret_material_rejected"
+ ("metadata", "field_hint"),
+ [
+ ({"name": "LOGIN", "kind": "static", "default_field": "value", "fields": ["value"]}, False),
+ ({"name": "LOGIN", "kind": "static", "default_field": "password", "fields": ["password"]}, True),
+ ({"name": "LOGIN", "kind": "static", "default_field": "password", "fields": ["password", "username"]}, True),
+ ({"name": "LOGIN", "kind": "static", "default_field": "value", "fields": ["value"], "fields_state": "corrupt"}, True),
+ ({"name": "SIGNING", "kind": "keypair", "default_field": "value", "fields": ["value"]}, False),
+ ],
+)
+def test_provision_field_hint_predicate_is_shared_across_callback_and_sync(metadata, field_hint, monkeypatch):
+ from vibe import cli
+
+ assert vault_service.has_named_field_shape(metadata) is field_hint
+ row = {
+ "id": "vrq_hint",
+ "request_type": "provision",
+ "status": "fulfilled",
+ "secret_name": metadata["name"],
+ "requester": json.dumps({}),
+ "delivery": json.dumps({}),
+ "provision_secret": metadata,
+ }
+ callback = vault_service._build_request_callback_message(row)
+ engine = MagicMock()
+ monkeypatch.setattr(vault_service, "get_secret_meta", lambda conn, name: metadata)
+ sync = cli._vault_provision_success_usage(engine, metadata["name"])
+ if field_hint:
+ assert "Current fields:" in callback and f"{metadata['name']}.{metadata['default_field']}" in callback
+ assert "Current fields:" in sync and f"{metadata['name']}.{metadata['default_field']}" in sync
+ else:
+ assert f"--env {metadata['name']} --" in callback and ".value" not in callback
+ assert f"--env {metadata['name']} --" in sync and ".value" not in sync
+
+
def test_find_reports_value_free_capabilities(tmp_path, capfd, monkeypatch):
_create_standard_secret("STANDARD_KEY")
with cli._open_vault_engine().begin() as conn:
@@ -405,6 +478,8 @@ def test_find_reports_value_free_capabilities(tmp_path, capfd, monkeypatch):
"name": "STANDARD_KEY",
"kind": "static",
"protection": "standard",
+ "default_field": "value",
+ "fields": ["value"],
"tags": [],
"description": None,
"policy": {},
@@ -446,6 +521,46 @@ def test_find_filters_by_query_and_multiple_tags(capfd):
assert payload["pagination"]["has_more"] is False
[email protected]("command", ["find", "list"])
[email protected]("query,expected_names", [
+ ("password", ["LOGIN"]), ("username", ["LOGIN"]),
+ ("LOGIN.password", ["LOGIN"]), ("LOGIN.username", ["LOGIN"]),
+ ("hidden_ciphertext", []),
+])
+def test_value_free_search_matches_field_labels(capfd, command, query, expected_names):
+ _create_standard_secret(
+ "LOGIN", default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("hidden_ciphertext")}],
+ )
+ _create_standard_secret("UNRELATED")
+ assert getattr(cli, f"cmd_vault_{command}")(_ns(query_filter=query)) == 0
+ payload = json.loads(capfd.readouterr().out)
+ assert [secret["name"] for secret in payload["secrets"]] == expected_names
+ assert "hidden_ciphertext" not in json.dumps(payload["secrets"])
+
+
[email protected]("command", ["run", "inject"])
[email protected]("selector", [{"tag": ["deploy"]}, {"skill": ["deploy"]}])
+def test_corrupt_fields_are_visible_and_selector_delivery_fails_closed(tmp_path, capfd, monkeypatch, command, selector):
+ from vibe import api
+
+ _create_standard_secret("CORRUPT", tags=["deploy", "skill:deploy"])
+ with cli._open_vault_engine().begin() as conn:
+ conn.execute(vault_service.vault_secrets.update().where(vault_service.vault_secrets.c.name == "CORRUPT").values(fields='[{"name":"username"}]'))
+ for lookup in (cli.cmd_vault_find, cli.cmd_vault_list):
+ assert lookup(_ns()) == 0
+ payload = json.loads(capfd.readouterr().out)
+ assert payload["secrets"][0]["fields_state"] == "corrupt"
+ assert payload["secrets"][0]["fields"] == ["value"]
+ deliver = Mock()
+ for mode in ("run", "inject"):
+ monkeypatch.setattr(api, f"avault_deliver_{mode}", deliver)
+ args = _ns(command_argv=["python3", "-c", "pass"], out=str(tmp_path / "unused.env"), format="dotenv", **selector)
+ assert getattr(cli, f"cmd_vault_{command}")(args) == 1
+ assert json.loads(capfd.readouterr().err)["code"] == "fields_corrupt"
+ deliver.assert_not_called()
+
+
def test_tags_lists_normal_and_skill_tags(capfd):
_create_standard_secret("OPENAI_PROD_KEY", tags=["openai", "prod", "skill:model-work"])
_create_standard_secret("OPENAI_DEV_KEY", tags=["openai", "dev", "skill:model-work"])
@@ -534,6 +649,14 @@ def test_access_request_cli_uses_caller_session(tmp_path, capfd, monkeypatch):
assert payload["request"]["status"] == "pending"
+def test_access_non_requestable_standard_secret_keeps_not_grantable_code(capfd):
+ _create_standard_secret("STANDARD_KEY")
+ assert cli.cmd_vault_access(_ns(name="STANDARD_KEY")) == 1
+ assert json.loads(capfd.readouterr().err)["code"] == "not_grantable"
+ with cli._open_vault_engine().connect() as conn:
+ assert vault_service.list_requests(conn) == []
+
+
def test_access_request_cli_accepts_protected_static_request(capfd):
with cli._open_vault_engine().begin() as conn:
vault_service.create_secret(conn, name="PROTECTED_KEY", protection="protected", sealed=_sealed("protected"))
@@ -546,6 +669,85 @@ def test_access_request_cli_accepts_protected_static_request(capfd):
assert payload["request"]["card"]["protection"] == "protected"
+ ("ref", "record"),
+ [("LOGIN.password", "LOGIN"), ("LOGIN.username", "LOGIN.username")],
+)
+def test_access_record_ref_uses_value_free_record_metadata(capfd, monkeypatch, ref, record):
+ with cli._open_vault_engine().begin() as conn:
+ vault_service.create_secret(
+ conn,
+ name="LOGIN",
+ protection="protected",
+ sealed=_sealed("password"),
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ metadata = Mock(wraps=vault_service.get_secret_record_meta)
+ monkeypatch.setattr(vault_service, "get_secret_record_meta", metadata)
+ for getter in ("get_envelope", "get_protected_envelope"):
+ monkeypatch.setattr(
+ vault_service,
+ getter,
+ Mock(side_effect=AssertionError("access validation must not load an envelope")),
+ )
+
+ assert cli.cmd_vault_access(_ns(name=ref)) == 0
+ payload = json.loads(capfd.readouterr().out)
+
+ metadata.assert_called_once()
+ assert metadata.call_args.args[1] == ref
+ assert payload["request"]["secret_name"] == "LOGIN"
+ assert payload["request"]["delivery"]["record"] == record
+
+
[email protected]("command", ["run", "fetch", "inject", "access"])
+ ("ref", "expected_code"),
+ [
+ ("LOGIN.missing", "field_not_found"),
+ ("LOGIN.UPPER", "invalid_field_name"),
+ ("LOGIN.bad-name", "invalid_field_name"),
+ ("SIGNING.value", "fields_not_supported"),
+ ],
+)
+def test_record_ref_errors_are_structured_before_delivery(
+ tmp_path, capfd, monkeypatch, command, ref, expected_code
+):
+ from vibe import api
+
+ _create_standard_secret(
+ "LOGIN",
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ _create_standard_secret("SIGNING", kind="keypair", signer_kind="local")
+ deliver = Mock()
+ for operation in ("run", "fetch", "inject"):
+ monkeypatch.setattr(api, f"avault_deliver_{operation}", deliver)
+ monkeypatch.setattr(api, f"avault_agent_deliver_{operation}", deliver)
+ args = _ns(
+ name=ref,
+ auth=ref,
+ env=[ref],
+ command_argv=["python3", "-c", "pass"],
+ url="https://api.github.com/user",
+ out=str(tmp_path / "login.env"),
+ format="dotenv",
+ )
+
+ assert getattr(cli, f"cmd_vault_{command}")(args) == 1
+ payload = json.loads(capfd.readouterr().err)
+
+ assert payload["code"] == expected_code
+ assert payload["help_command"] == f"vibe vault {command} --help"
+ if expected_code == "field_not_found":
+ assert "password, username" in payload["error"]
+ deliver.assert_not_called()
+ with cli._open_vault_engine().connect() as conn:
+ assert vault_service.list_requests(conn) == []
+
+
def test_sign_cli_standard_key_returns_inline_signature_without_request(capfd, monkeypatch):
from vibe import api
@@ -735,7 +937,7 @@ def test_run_calls_avault_with_env_mapping_and_records_delivery(tmp_path, capfd,
code = cli.cmd_vault_run(_ns(env=["LOCAL_NAME=SRC_KEY"], command_argv=["python3", "-c", "pass"]))
assert code == 0
deliver.assert_called_once_with(
- [{"name": "SRC_KEY", "env": "LOCAL_NAME", "envelope": _sealed("run")}],
+ [{"name": "SRC_KEY", "env": "LOCAL_NAME", "envelope": _sealed("run"), "tier": "standard"}],
["python3", "-c", "pass"],
)
cli.cmd_vault_list(_ns())
@@ -744,6 +946,109 @@ def test_run_calls_avault_with_env_mapping_and_records_delivery(tmp_path, capfd,
assert secret["last_used_at"] is not None
+def test_run_canonicalizes_default_alias_and_delivers_extra_field(tmp_path, capfd, monkeypatch):
+ from vibe import api
+
+ _create_standard_secret(
+ "GITHUB_LOGIN",
+ sealed=_sealed("password"),
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ deliver = Mock(return_value=0)
+ monkeypatch.setattr(api, "avault_deliver_run", deliver)
+
+ assert cli.cmd_vault_run(
+ _ns(
+ env=["GITHUB_LOGIN.password", "GITHUB_LOGIN.username"],
+ command_argv=["python3", "-c", "pass"],
+ )
+ ) == 0
+
+ assert deliver.call_args.args[0] == [
+ {
+ "name": "GITHUB_LOGIN",
+ "env": "GITHUB_LOGIN_PASSWORD",
+ "envelope": _sealed("password"),
+ "tier": "standard",
+ },
+ {
+ "name": "GITHUB_LOGIN.username",
+ "env": "GITHUB_LOGIN_USERNAME",
+ "envelope": _sealed("username"),
+ "tier": "standard",
+ },
+ ]
+
+
+def test_completed_run_audits_snapshot_fields_removed_or_renamed_during_child(capfd, monkeypatch):
+ from vibe import api
+
+ _create_standard_secret("LOGIN", default_field="password", fields=[{"name": "username", "sealed": _sealed("user")}])
+ _create_standard_secret("OTHER", fields=[{"name": "token", "sealed": _sealed("token")}])
+
+ def finish_run(secrets, command):
+ assert {entry["name"] for entry in secrets} == {"LOGIN", "LOGIN.username", "OTHER.token"}
+ with cli._open_vault_engine().begin() as conn:
+ vault_service.remove_secret_field(conn, "LOGIN", "username")
+ vault_service.update_secret_metadata(conn, "LOGIN", default_field="credential")
+ return {"exit_code": 0, "delivered": True}
+
+ monkeypatch.setattr(api, "avault_deliver_run", finish_run)
+ assert cli.cmd_vault_run(_ns(env=["LOGIN", "LOGIN.username", "OTHER.token"], command_argv=["python3", "-c", "pass"])) == 0
+ with cli._open_vault_engine().connect() as conn:
+ assert vault_service.get_secret_meta(conn, "LOGIN")["use_count"] == 1
+ assert vault_service.get_secret_meta(conn, "OTHER")["use_count"] == 1
+ delivered = {
+ event["secret_name"]: json.loads(event["delivery"])["fields"]
+ for event in vault_service.list_audit(conn)
+ if event["event"] == "delivered"
+ }
+ assert delivered == {"LOGIN": ["password", "username"], "OTHER": ["token"]}
+
+
+def test_run_rejects_alias_collision_after_record_canonicalization(capfd, monkeypatch):
+ from vibe import api
+
+ _create_standard_secret(
+ "GITHUB_LOGIN",
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ deliver = Mock()
+ monkeypatch.setattr(api, "avault_deliver_run", deliver)
+
+ code = cli.cmd_vault_run(
+ _ns(
+ env=["PASSWORD=GITHUB_LOGIN", "EXPLICIT=GITHUB_LOGIN.password"],
+ command_argv=["python3", "-c", "pass"],
+ )
+ )
+ payload = json.loads(capfd.readouterr().err)
+
+ assert code == 1
+ assert payload["code"] == "conflicting_env_alias"
+ deliver.assert_not_called()
+
+
+def test_run_dedupes_default_refs_with_the_same_env_alias(capfd, monkeypatch):
+ from vibe import api
+
+ _create_standard_secret("LOGIN", default_field="password")
+ deliver = Mock(return_value=0)
+ monkeypatch.setattr(api, "avault_deliver_run", deliver)
+
+ assert cli.cmd_vault_run(
+ _ns(
+ env=["PASSWORD=LOGIN,PASSWORD=LOGIN.password"],
+ command_argv=["python3", "-c", "pass"],
+ )
+ ) == 0
+ assert deliver.call_args.args[0] == [
+ {"name": "LOGIN", "env": "PASSWORD", "envelope": _sealed(), "tier": "standard"}
+ ]
+
+
def test_run_expands_tags_and_skill_tags_as_union(capfd, monkeypatch):
from vibe import api
@@ -760,6 +1065,40 @@ def test_run_expands_tags_and_skill_tags_as_union(capfd, monkeypatch):
assert delivered == {"A_KEY": "A_KEY", "B_KEY": "B_KEY", "C_KEY": "C_KEY"}
[email protected]("selector", [{"tag": ["deploy"]}, {"skill": ["release"]}])
+def test_run_tag_and_skill_select_every_field(capfd, monkeypatch, selector):
+ from vibe import api
+
+ _create_standard_secret(
+ "DEPLOY_LOGIN",
+ sealed=_sealed("password"),
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ tags=["deploy", "skill:release"],
+ )
+ deliver = Mock(return_value=0)
+ monkeypatch.setattr(api, "avault_deliver_run", deliver)
+
+ assert cli.cmd_vault_run(
+ _ns(**selector, command_argv=["python3", "-c", "pass"])
+ ) == 0
+
+ assert deliver.call_args.args[0] == [
+ {
+ "name": "DEPLOY_LOGIN",
+ "env": "DEPLOY_LOGIN",
+ "envelope": _sealed("password"),
+ "tier": "standard",
+ },
+ {
+ "name": "DEPLOY_LOGIN.username",
+ "env": "DEPLOY_LOGIN_USERNAME",
+ "envelope": _sealed("username"),
+ "tier": "standard",
+ },
+ ]
+
+
def test_run_skill_selects_skill_link_mirror_tag(monkeypatch):
from vibe import api
@@ -772,7 +1111,9 @@ def test_run_skill_selects_skill_link_mirror_tag(monkeypatch):
code = cli.cmd_vault_run(_ns(skill=["deploy"], command_argv=["python3", "-c", "pass"]))
assert code == 0
- assert deliver.call_args.args[0] == [{"name": "LINKED_KEY", "env": "LINKED_KEY", "envelope": _sealed("linked")}]
+ assert deliver.call_args.args[0] == [
+ {"name": "LINKED_KEY", "env": "LINKED_KEY", "envelope": _sealed("linked"), "tier": "standard"}
+ ]
@pytest.mark.parametrize("selector", [{"tag": ["missing"]}, {"skill": ["missing"]}])
@@ -1130,7 +1471,7 @@ def test_inject_resolver_uses_session_bound_protected_grant(tmp_path):
resolved_grant, one_shot_grants, secrets = cli._resolve_vault_inject_delivery(
engine,
- ["PROTECTED_KEY"],
+ {"PROTECTED_KEY": "PROTECTED_KEY"},
path=str(tmp_path / "out.env"),
fmt="dotenv",
args=_ns(session_id="ses_cli"),
@@ -1138,7 +1479,9 @@ def test_inject_resolver_uses_session_bound_protected_grant(tmp_path):
assert resolved_grant["id"] == grant["id"]
assert one_shot_grants == []
- assert secrets == [{"name": "PROTECTED_KEY", "key": "PROTECTED_KEY", "envelope": _sealed("protected")}]
+ assert secrets == [
+ {"name": "PROTECTED_KEY", "key": "PROTECTED_KEY", "envelope": _sealed("protected"), "tier": "protected"}
+ ]
def test_run_fast_path_reserves_protected_always_ask_grant(tmp_path, capfd, monkeypatch):
@@ -1305,8 +1648,8 @@ def test_run_reuses_multi_secret_standard_one_shot_grant(tmp_path, capfd, monkey
assert code == 0
deliver.assert_called_once_with(
[
- {"name": "ASK_A", "env": "A", "envelope": _sealed("ask_a")},
- {"name": "ASK_B", "env": "B", "envelope": _sealed("ask_b")},
+ {"name": "ASK_A", "env": "A", "envelope": _sealed("ask_a"), "tier": "standard"},
+ {"name": "ASK_B", "env": "B", "envelope": _sealed("ask_b"), "tier": "standard"},
],
["python3", "-c", "pass"],
)
@@ -1369,9 +1712,9 @@ def test_run_tag_reuses_standard_one_shot_subset_with_normal_secrets(tmp_path, c
assert code == 0
deliver.assert_called_once_with(
[
- {"name": "ASK_A", "env": "ASK_A", "envelope": _sealed("ask_a")},
- {"name": "ASK_B", "env": "ASK_B", "envelope": _sealed("ask_b")},
- {"name": "NORMAL_DEPLOY", "env": "NORMAL_DEPLOY", "envelope": _sealed("normal")},
+ {"name": "ASK_A", "env": "ASK_A", "envelope": _sealed("ask_a"), "tier": "standard"},
+ {"name": "ASK_B", "env": "ASK_B", "envelope": _sealed("ask_b"), "tier": "standard"},
+ {"name": "NORMAL_DEPLOY", "env": "NORMAL_DEPLOY", "envelope": _sealed("normal"), "tier": "standard"},
],
["python3", "-c", "pass"],
)
@@ -1395,8 +1738,8 @@ def test_inject_reuses_multi_secret_standard_one_shot_grant(tmp_path, capfd, mon
str(out),
"dotenv",
[
- {"name": "ASK_A", "key": "ASK_A", "envelope": _sealed("ask_a")},
- {"name": "ASK_B", "key": "ASK_B", "envelope": _sealed("ask_b")},
+ {"name": "ASK_A", "key": "ASK_A", "envelope": _sealed("ask_a"), "tier": "standard"},
+ {"name": "ASK_B", "key": "ASK_B", "envelope": _sealed("ask_b"), "tier": "standard"},
],
)
with cli._open_vault_engine().connect() as conn:
@@ -1441,7 +1784,7 @@ def test_run_consumes_standard_always_ask_grant_after_delivery(tmp_path, capfd,
assert code == 0
deliver.assert_called_once_with(
- [{"name": "ASK_KEY", "env": "ASK_KEY", "envelope": _sealed("ask_key")}],
+ [{"name": "ASK_KEY", "env": "ASK_KEY", "envelope": _sealed("ask_key"), "tier": "standard"}],
["python3", "-c", "pass"],
)
with cli._open_vault_engine().connect() as conn:
@@ -1460,7 +1803,7 @@ def test_run_consumes_standard_always_ask_grant_when_child_exits_70(tmp_path, ca
assert code == 70
deliver.assert_called_once_with(
- [{"name": "ASK_KEY", "env": "ASK_KEY", "envelope": _sealed("ask_key")}],
+ [{"name": "ASK_KEY", "env": "ASK_KEY", "envelope": _sealed("ask_key"), "tier": "standard"}],
["python3", "-c", "raise SystemExit(70)"],
)
with cli._open_vault_engine().connect() as conn:
@@ -1574,7 +1917,11 @@ def test_inject_uses_resolved_output_path_for_standard_always_ask_delivery(tmp_p
assert code == 0
assert payload["path"] == expected
- deliver.assert_called_once_with(expected, "dotenv", [{"name": "ASK_KEY", "key": "ASK_KEY", "envelope": _sealed("ask_key")}])
+ deliver.assert_called_once_with(
+ expected,
+ "dotenv",
+ [{"name": "ASK_KEY", "key": "ASK_KEY", "envelope": _sealed("ask_key"), "tier": "standard"}],
+ )
with cli._open_vault_engine().connect() as conn:
status = conn.execute(vault_grants.select().where(vault_grants.c.id == grant["id"])).mappings().one()["status"]
assert status == "expired"
@@ -1918,17 +2265,24 @@ def test_run_expires_grant_when_agent_cache_is_missing(capfd, monkeypatch):
assert requests[0]["card"]["grant_options"][0]["purpose"] == "run"
-def test_run_reopens_one_selector_set_when_agent_cache_is_missing(capfd, monkeypatch):
[email protected]("field_refs", [False, True])
+def test_run_reopens_one_selector_set_when_agent_cache_is_missing(capfd, monkeypatch, field_refs):
from vibe import api
- grant = _set_tag_grant(["A_KEY", "B_KEY"])
- monkeypatch.setattr(api, "avault_agent_deliver_run", Mock(side_effect=api.AvaultError("grant is missing or expired")))
+ grant = _set_tag_grant(
+ ["A_KEY", "B_KEY"],
+ fields=[{"name": "username", "sealed": _sealed("username")}] if field_refs else None,
+ )
+ refs = ["A_KEY.username", "B_KEY.username"] if field_refs else ["A_KEY", "B_KEY"]
+ deliver = Mock(side_effect=api.AvaultError("grant is missing or expired"))
+ monkeypatch.setattr(api, "avault_agent_deliver_run", deliver)
- code = cli.cmd_vault_run(_ns(env=["A_KEY", "B_KEY"], command_argv=["python3", "-c", "pass"]))
+ code = cli.cmd_vault_run(_ns(env=refs, command_argv=["python3", "-c", "pass"]))
captured = capfd.readouterr()
assert code == 1
assert json.loads(captured.err)["code"] == "approval_required"
+ assert [item["name"] for item in deliver.call_args.kwargs["secrets"]] == refs
with cli._open_vault_engine().connect() as conn:
status = conn.execute(vault_grants.select().where(vault_grants.c.id == grant["id"])).mappings().one()["status"]
requests = vault_service.list_requests(conn, status="pending")
@@ -1936,9 +2290,12 @@ def test_run_reopens_one_selector_set_when_agent_cache_is_missing(capfd, monkeyp
assert len(requests) == 1
assert requests[0]["secret_name"] is None
assert requests[0]["delivery"]["protected_secret_names"] == ["A_KEY", "B_KEY"]
- assert requests[0]["delivery"]["source_selector"] == {"env": ["A_KEY", "B_KEY"]}
+ expected_selector = {
+ "env": ["A_KEY_USERNAME=A_KEY.username", "B_KEY_USERNAME=B_KEY.username"] if field_refs else refs
+ }
+ assert requests[0]["delivery"]["source_selector"] == expected_selector
option = requests[0]["card"]["grant_options"][0]
- assert option["source_selector"] == {"env": ["A_KEY", "B_KEY"]}
+ assert option["source_selector"] == expected_selector
assert option["member_snapshot"] == ["A_KEY", "B_KEY"]
@@ -2054,7 +2411,7 @@ def test_inject_resolver_publishes_pending_request_when_approval_required(tmp_pa
with pytest.raises(cli.TaskCliError) as exc_info:
cli._resolve_vault_inject_delivery(
cli._open_vault_engine(),
- ["PROTECTED_KEY"],
+ {"PROTECTED_KEY": "PROTECTED_KEY"},
path=str(tmp_path / "out.env"),
fmt="dotenv",
args=_ns(session_id="ses_cli"),
@@ -2240,6 +2597,40 @@ def test_request_for_existing_secret_returns_fulfilled(tmp_path, capfd, monkeypa
assert json.loads(capfd.readouterr().out)["status"] == "fulfilled"
[email protected]("already_exists", [False, True])
[email protected]("with_spec", [False, True])
+def test_field_provision_success_hints_use_current_subset(capfd, monkeypatch, already_exists, with_spec):
+ def provide_subset():
+ _create_standard_secret(
+ "LOGIN", default_field="credential", sealed=_sealed("do-not-expose"),
+ fields=[{"name": "username", "sealed": _sealed("hidden-user")}],
+ )
+
+ def complete_during_wait(request_id, **_kwargs):
+ provide_subset()
+ with cli._open_vault_engine().connect() as conn:
+ return vault_service.get_request(conn, request_id)
+
+ wait = Mock(side_effect=complete_during_wait)
+ monkeypatch.setattr(cli, "_wait_for_provision", wait)
+ if already_exists:
+ provide_subset()
+ request_args = ["vault", "request", "LOGIN", "--wait", "30"]
+ if with_spec:
+ request_args.extend(["--spec-json", '{"fields":["username","password","totp"],"default_field":"password"}'])
+ args = cli.build_parser().parse_args(request_args)
+ assert cli.cmd_vault_request(args) == 0
+ payload = json.loads(capfd.readouterr().out)
+ assert payload["status"] == "fulfilled"
+ assert wait.call_count == (0 if already_exists else 1)
+ message = payload["message"]
+ assert "credential" in message and "username" in message
+ assert "LOGIN.credential" in message
+ assert "vibe vault run --env LOGIN.username" in message
+ assert "password" not in message and "totp" not in message
+ assert "do-not-expose" not in message and "hidden-user" not in message
+
+
def test_request_wait_outputs_fulfilled_request(capfd, monkeypatch):
def wait_mock(request_id, *, timeout, poll_interval=2.0):
with cli._open_vault_engine().begin() as conn:
diff --git a/tests/test_vault_export_inject.py b/tests/test_vault_export_inject.py
index 2ab9ed391..864e042d3 100644
--- a/tests/test_vault_export_inject.py
+++ b/tests/test_vault_export_inject.py
@@ -8,7 +8,9 @@ import json
import pytest
from storage import vault_service
+from storage.models import vault_grants
from storage.vault_crypto import Sealed
+from sqlalchemy import select
from vibe import cli
@@ -37,9 +39,25 @@ def _sealed(suffix: str = "1") -> Sealed:
return Sealed(ciphertext=f"ct-{suffix}", nonce=f"n-{suffix}", wrap_meta=f"wm-{suffix}")
-def _create_standard_secret(name: str, *, sealed: Sealed | None = None):
+def _create_standard_secret(
+ name: str,
+ *,
+ sealed: Sealed | None = None,
+ default_field: str | None = None,
+ fields: list[dict] | None = None,
+ tags: list[str] | None = None,
+ policy: dict | None = None,
+):
with cli._open_vault_engine().begin() as conn:
- vault_service.create_secret(conn, name=name, sealed=sealed or _sealed(name.lower()))
+ vault_service.create_secret(
+ conn,
+ name=name,
+ sealed=sealed or _sealed(name.lower()),
+ default_field=default_field,
+ fields=fields,
+ tags=tags,
+ policy=policy,
+ )
def _grant_from_request(conn, request: dict, *, session_id: str | None = None) -> dict:
@@ -96,8 +114,8 @@ def test_inject_calls_avault_and_records_delivery(tmp_path, capfd, monkeypatch,
str(out),
fmt,
[
- {"name": "A_KEY", "key": "A_KEY", "envelope": _sealed("a")},
- {"name": "B_KEY", "key": "B_KEY", "envelope": _sealed("b")},
+ {"name": "A_KEY", "key": "A_KEY", "envelope": _sealed("a"), "tier": "standard"},
+ {"name": "B_KEY", "key": "B_KEY", "envelope": _sealed("b"), "tier": "standard"},
],
)
cli.cmd_vault_list(_ns())
@@ -106,6 +124,255 @@ def test_inject_calls_avault_and_records_delivery(tmp_path, capfd, monkeypatch,
assert secrets["B_KEY"]["use_count"] == 1
+def test_inject_canonicalizes_default_alias_and_maps_extra_field_key(tmp_path, capfd, monkeypatch):
+ from unittest.mock import Mock
+
+ from vibe import api
+
+ _create_standard_secret(
+ "LOGIN",
+ sealed=_sealed("password"),
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ inject = Mock(return_value=None)
+ monkeypatch.setattr(api, "avault_deliver_inject", inject)
+ out = tmp_path / "login.env"
+
+ assert cli.cmd_vault_inject(
+ _ns(keys="LOGIN.password,LOGIN.username", out=str(out), format="dotenv")
+ ) == 0
+ capfd.readouterr()
+
+ inject.assert_called_once_with(
+ str(out),
+ "dotenv",
+ [
+ {
+ "name": "LOGIN",
+ "key": "LOGIN_PASSWORD",
+ "envelope": _sealed("password"),
+ "tier": "standard",
+ },
+ {
+ "name": "LOGIN.username",
+ "key": "LOGIN_USERNAME",
+ "envelope": _sealed("username"),
+ "tier": "standard",
+ },
+ ],
+ )
+
+
[email protected]("selector", [{"tag": ["deploy"]}, {"skill": ["release"]}])
+def test_inject_accepts_tag_and_skill_selectors_for_all_fields(tmp_path, capfd, monkeypatch, selector):
+ from unittest.mock import Mock
+
+ from vibe import api
+
+ _create_standard_secret(
+ "DEPLOY_LOGIN",
+ sealed=_sealed("password"),
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ tags=["deploy", "skill:release"],
+ )
+ inject = Mock(return_value=None)
+ monkeypatch.setattr(api, "avault_deliver_inject", inject)
+ out = tmp_path / "deploy.env"
+
+ assert cli.cmd_vault_inject(
+ _ns(**selector, out=str(out), format="dotenv")
+ ) == 0
+ capfd.readouterr()
+
+ assert inject.call_args.args[2] == [
+ {
+ "name": "DEPLOY_LOGIN",
+ "key": "DEPLOY_LOGIN",
+ "envelope": _sealed("password"),
+ "tier": "standard",
+ },
+ {
+ "name": "DEPLOY_LOGIN.username",
+ "key": "DEPLOY_LOGIN_USERNAME",
+ "envelope": _sealed("username"),
+ "tier": "standard",
+ },
+ ]
+
+
+def test_inject_rejects_selector_record_conflict_before_avault(tmp_path, capfd, monkeypatch):
+ from unittest.mock import Mock
+
+ from vibe import api
+
+ _create_standard_secret(
+ "LOGIN",
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ inject = Mock()
+ monkeypatch.setattr(api, "avault_deliver_inject", inject)
+
+ code = cli.cmd_vault_inject(
+ _ns(
+ env=["A=LOGIN", "B=LOGIN.password"],
+ out=str(tmp_path / "conflict.env"),
+ format="dotenv",
+ )
+ )
+ payload = json.loads(capfd.readouterr().err)
+
+ assert code == 1
+ assert payload["code"] == "conflicting_env_alias"
+ inject.assert_not_called()
+
+
[email protected]("protection", ["standard", "protected"])
+ "selector",
+ [
+ {"keys": "ASK_LOGIN.password,ASK_LOGIN.username"},
+ {"env": ["ASK_LOGIN.password", "ASK_LOGIN.username"]},
+ ],
+)
+def test_inject_one_shot_field_pair_records_one_secret_delivery(
+ tmp_path, capfd, monkeypatch, protection, selector
+):
+ from unittest.mock import Mock
+
+ from vibe import api
+
+ with cli._open_vault_engine().begin() as conn:
+ vault_service.create_secret(
+ conn,
+ name="ASK_LOGIN",
+ protection=protection,
+ sealed=_sealed("password"),
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ policy={"always_ask": True},
+ )
+ request = vault_service.create_access_request(
+ conn,
+ "ASK_LOGIN",
+ purpose="inject",
+ requester={"source": "cli"},
+ delivery={"mode": "inject"},
+ )
+ grant = _grant_from_request(conn, request)
+
+ inject = Mock(return_value=None)
+ monkeypatch.setattr(
+ api,
+ "avault_agent_deliver_inject" if protection == "protected" else "avault_deliver_inject",
+ inject,
+ )
+ out = tmp_path / "ask-login.env"
+
+ assert cli.cmd_vault_inject(
+ _ns(**selector, out=str(out), format="dotenv")
+ ) == 0
+ capfd.readouterr()
+
+ inject.assert_called_once()
+ records = inject.call_args.kwargs["secrets"] if protection == "protected" else inject.call_args.args[2]
+ assert records == [
+ {
+ "name": "ASK_LOGIN",
+ "key": "ASK_LOGIN_PASSWORD",
+ "envelope": _sealed("password"),
+ "tier": protection,
+ },
+ {
+ "name": "ASK_LOGIN.username",
+ "key": "ASK_LOGIN_USERNAME",
+ "envelope": _sealed("username"),
+ "tier": protection,
+ },
+ ]
+ with cli._open_vault_engine().connect() as conn:
+ status = conn.execute(
+ select(vault_grants.c.status).where(vault_grants.c.id == grant["id"])
+ ).scalar_one()
+ meta = vault_service.get_secret_meta(conn, "ASK_LOGIN")
+ audits = vault_service.list_audit(conn, secret_name="ASK_LOGIN")
+ assert status == "expired"
+ assert meta["use_count"] == 1
+ delivered = [row for row in audits if row["event"] == "delivered"]
+ assert json.loads(delivered[-1]["delivery"])["fields"] == ["password", "username"]
+
+
[email protected]("protection", ["standard", "protected"])
+def test_inject_tag_approval_covers_secret_members_and_delivers_all_fields(
+ tmp_path, capfd, monkeypatch, protection
+):
+ from unittest.mock import Mock
+
+ from vibe import api
+
+ with cli._open_vault_engine().begin() as conn:
+ vault_service.create_secret(
+ conn,
+ name="LOGIN",
+ protection=protection,
+ sealed=_sealed("password"),
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ tags=["deploy"],
+ policy={"always_ask": True} if protection == "standard" else {},
+ )
+ vault_service.create_secret(
+ conn,
+ name="OTHER",
+ protection=protection,
+ sealed=_sealed("other"),
+ tags=["deploy"],
+ )
+ inject = Mock(return_value=None)
+ monkeypatch.setattr(
+ api,
+ "avault_agent_deliver_inject" if protection == "protected" else "avault_deliver_inject",
+ inject,
+ )
+ args = _ns(tag=["deploy"], out=str(tmp_path / "deploy.env"), format="dotenv")
+
+ assert cli.cmd_vault_inject(args) == 1
+ assert json.loads(capfd.readouterr().err)["code"] == "approval_required"
+ inject.assert_not_called()
+ with cli._open_vault_engine().begin() as conn:
+ requests = vault_service.list_requests(conn, status="pending")
+ assert len(requests) == 1
+ request = requests[0]
+ assert request["card"]["grant_options"][0]["member_snapshot"] == (
+ ["LOGIN", "OTHER"] if protection == "protected" else ["LOGIN"]
+ )
+ grant = _grant_from_request(conn, request)
+
+ assert cli.cmd_vault_inject(args) == 0
+ capfd.readouterr()
+ records = inject.call_args.kwargs["secrets"] if protection == "protected" else inject.call_args.args[2]
+ assert [(item["name"], item["key"], item["tier"]) for item in records] == [
+ ("LOGIN", "LOGIN", protection),
+ ("LOGIN.username", "LOGIN_USERNAME", protection),
+ ("OTHER", "OTHER", protection),
+ ]
+ if protection == "protected":
+ inject.side_effect = api.AvaultError("grant is missing or expired")
+ assert cli.cmd_vault_inject(args) == 1
+ assert json.loads(capfd.readouterr().err)["code"] == "approval_required"
+ with cli._open_vault_engine().connect() as conn:
+ requests = vault_service.list_requests(conn, status="pending")
+ status = conn.execute(
+ select(vault_grants.c.status).where(vault_grants.c.id == grant["id"])
+ ).scalar_one()
+ assert status == "expired"
+ assert len(requests) == 1
+ assert requests[0]["card"]["grant_options"][0]["member_snapshot"] == ["LOGIN", "OTHER"]
+ assert requests[0]["delivery"]["protected_secret_names"] == ["LOGIN", "OTHER"]
+
+
def test_inject_rejects_keypair_before_avault_delivery(tmp_path, capfd, monkeypatch):
from unittest.mock import Mock
@@ -141,7 +408,14 @@ def test_inject_uses_agent_delivery_for_protected_grant(tmp_path, capfd, monkeyp
grant_id=grant["id"],
path=str(out),
fmt="dotenv",
- secrets=[{"name": "PROTECTED_KEY", "key": "PROTECTED_KEY", "envelope": _sealed("protected_key")}],
+ secrets=[
+ {
+ "name": "PROTECTED_KEY",
+ "key": "PROTECTED_KEY",
+ "envelope": _sealed("protected_key"),
+ "tier": "protected",
+ }
+ ],
)
assert "value" not in repr(inject.call_args.kwargs)
@@ -165,7 +439,14 @@ def test_inject_resolves_protected_relative_output_in_caller_cwd(tmp_path, capfd
grant_id=grant["id"],
path=expected,
fmt="dotenv",
- secrets=[{"name": "PROTECTED_KEY", "key": "PROTECTED_KEY", "envelope": _sealed("protected_key")}],
+ secrets=[
+ {
+ "name": "PROTECTED_KEY",
+ "key": "PROTECTED_KEY",
+ "envelope": _sealed("protected_key"),
+ "tier": "protected",
+ }
+ ],
)
assert payload["path"] == expected
@@ -246,7 +527,11 @@ def test_inject_dedupes_repeated_keys(tmp_path, capfd, monkeypatch):
out = tmp_path / "dup.env"
assert cli.cmd_vault_inject(_ns(keys="A_KEY,A_KEY", out=str(out), format="dotenv")) == 0
assert json.loads(capfd.readouterr().out)["keys"] == ["A_KEY"]
- inject.assert_called_once_with(str(out), "dotenv", [{"name": "A_KEY", "key": "A_KEY", "envelope": _sealed("a")}])
+ inject.assert_called_once_with(
+ str(out),
+ "dotenv",
+ [{"name": "A_KEY", "key": "A_KEY", "envelope": _sealed("a"), "tier": "standard"}],
+ )
cli.cmd_vault_list(_ns())
assert json.loads(capfd.readouterr().out)["secrets"][0]["use_count"] == 1
diff --git a/tests/test_vault_fetch.py b/tests/test_vault_fetch.py
index 42d4c5043..26af958ec 100644
--- a/tests/test_vault_fetch.py
+++ b/tests/test_vault_fetch.py
@@ -54,6 +54,9 @@ def _create_standard_secret(
allow_host: list[str] | None = None,
auth_header: str | None = None,
auth_query: str | None = None,
+ sealed: Sealed | None = None,
+ default_field: str | None = None,
+ fields: list[dict] | None = None,
) -> None:
policy: dict = {}
if allow_host:
@@ -66,8 +69,10 @@ def _create_standard_secret(
vault_service.create_secret(
conn,
name=name,
- sealed=_sealed(name.lower()),
+ sealed=sealed or _sealed(name.lower()),
policy=policy or None,
+ default_field=default_field,
+ fields=fields,
)
@@ -171,6 +176,49 @@ def test_fetch_passes_bearer_request_to_avault_and_writes_stdout(tmp_path, capfd
assert vault_service.get_secret_meta(conn, "GH_PAT")["use_count"] == 1
+ ("auth", "expected_name", "expected_sealed", "expected_field"),
+ [
+ ("GH_LOGIN.password", "GH_LOGIN", _sealed("password"), "password"),
+ ("GH_LOGIN.username", "GH_LOGIN.username", _sealed("username"), "username"),
+ ],
+)
+def test_fetch_canonicalizes_record_name_and_uses_secret_policy(
+ capfd,
+ monkeypatch,
+ auth,
+ expected_name,
+ expected_sealed,
+ expected_field,
+):
+ from unittest.mock import Mock
+
+ from vibe import api
+
+ _create_standard_secret(
+ "GH_LOGIN",
+ allow_host=["api.github.com"],
+ sealed=_sealed("password"),
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ fetch = Mock(return_value={"status": 200, "headers": {}, "body": "ok"})
+ monkeypatch.setattr(api, "avault_deliver_fetch", fetch)
+
+ assert cli.cmd_vault_fetch(_ns(auth=auth, url="https://api.github.com/user")) == 0
+ capfd.readouterr()
+
+ name, sealed, request = fetch.call_args.args
+ assert name == expected_name
+ assert sealed == expected_sealed
+ assert request["allowed_hosts"] == ["api.github.com"]
+ with cli._open_vault_engine().connect() as conn:
+ assert vault_service.get_secret_meta(conn, "GH_LOGIN")["use_count"] == 1
+ audit_rows = vault_service.list_audit(conn, secret_name="GH_LOGIN")
+ proxied = [row for row in audit_rows if row["event"] == "proxied"]
+ assert json.loads(proxied[-1]["delivery"])["field"] == expected_field
+
+
def test_fetch_rejects_keypair_before_avault_delivery(capfd, monkeypatch):
from unittest.mock import Mock
diff --git a/tests/test_vault_request_callbacks.py b/tests/test_vault_request_callbacks.py
index c028109b3..b6a36132e 100644
--- a/tests/test_vault_request_callbacks.py
+++ b/tests/test_vault_request_callbacks.py
@@ -18,7 +18,7 @@ from modules.im import MessageContext
from storage import vault_service as vs
from storage import messages_service
from storage.db import create_sqlite_engine
-from storage.models import metadata, vault_requests
+from storage.models import metadata, vault_requests, vault_secrets
from storage.vault_crypto import Sealed
@@ -128,6 +128,53 @@ def test_provision_fulfill_arms_callback(vault):
assert plan is not None and "provided" in plan.message.lower()
[email protected]("with_spec", [False, True])
+def test_field_provision_callback_reports_current_value_free_fields(vault, with_spec):
+ with vault.begin() as conn:
+ req = vs.create_provision_request(
+ conn, "LOGIN", requester={"session_id": "ses_p"},
+ spec={"fields": ["username", "password", "totp"], "default_field": "password"} if with_spec else None,
+ )
+ vs.create_secret(
+ conn, name="LOGIN", default_field="password", sealed=_sealed("do-not-show-default"),
+ fields=[{"name": "username", "sealed": _sealed("do-not-show-extra")}],
+ )
+ vs.update_secret_metadata(conn, "LOGIN", default_field="credential")
+ pending = next(row for row in vs.list_pending_request_callbacks(conn) if row["id"] == req["id"])
+ plan = vs.resolve_request_callback(pending)
+ assert plan is not None
+ assert "credential" in plan.message and "username" in plan.message
+ assert "LOGIN.username" in plan.message or "LOGIN.credential" in plan.message
+ assert "--env" in plan.message
+ assert "totp" not in plan.message and "password" not in plan.message
+ assert "do-not-show" not in plan.message
+ assert "ciphertext" not in plan.message
+
+
+ ("default_field", "corrupt", "expected"),
+ [("password", False, "LOGIN.password"), ("value", True, "corrupt")],
+)
+def test_async_field_provision_callback_attaches_single_custom_and_corrupt_shapes(
+ vault, default_field, corrupt, expected,
+):
+ with vault.begin() as conn:
+ req = vs.create_provision_request(conn, "LOGIN", requester={"session_id": "ses_p"})
+ vs.create_secret(conn, name="LOGIN", default_field=default_field, sealed=_sealed("do-not-show"))
+ if corrupt:
+ conn.execute(
+ vault_secrets.update()
+ .where(vault_secrets.c.name == "LOGIN")
+ .values(fields="{malformed")
+ )
+ pending = next(row for row in vs.list_pending_request_callbacks(conn) if row["id"] == req["id"])
+ plan = vs.resolve_request_callback(pending)
+ assert plan is not None
+ assert expected in plan.message
+ assert "Current fields:" in plan.message
+ assert "do-not-show" not in plan.message
+
+
def test_expiry_arms_callback(vault):
past = (datetime.now(timezone.utc) - timedelta(minutes=1)).isoformat()
with vault.begin() as conn:
diff --git a/tests/test_vault_rest.py b/tests/test_vault_rest.py
index 85c41086f..f520b9f33 100644
--- a/tests/test_vault_rest.py
+++ b/tests/test_vault_rest.py
@@ -550,3 +550,77 @@ def test_rest_sign_errors_are_stable(monkeypatch):
)
assert not_key.status_code == 409
assert not_key.get_json()["code"] == "not_signing_key"
+
+
+def test_rest_field_put_delete_routes_use_canonical_record_name(monkeypatch):
+ seal = Mock(side_effect=[_sealed("default"), _sealed("username"), _sealed("newer")])
+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)
+ api.create_vault_secret(
+ {
+ "name": "REST_LOGIN",
+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "default"},
+ }
+ )
+ client = app.test_client()
+ headers = csrf_headers(client)
+
+ put = client.put(
+ "/api/vault/secrets/REST_LOGIN/fields/username",
+ json={
+ "record": "REST_LOGIN.username",
+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "username"},
+ },
+ headers=headers,
+ )
+ assert put.status_code == 200
+ assert put.get_json()["secret"]["fields"] == ["value", "username"]
+ assert seal.call_args_list[1].args[0] == "REST_LOGIN.username"
+
+ old_version = put.get_json()["secret"]["updated_at"]
+ newer = api.update_vault_secret_field("REST_LOGIN", "username", {
+ "record": "REST_LOGIN.username",
+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "newer"},
+ })
+ stale = client.delete(
+ "/api/vault/secrets/REST_LOGIN/fields/username",
+ json={"expected_updated_at": old_version}, headers=headers,
+ )
+ assert stale.status_code == 409
+ assert stale.get_json()["code"] == "secret_conflict"
+ assert api.get_vault_secrets()["secrets"][0]["fields"] == ["value", "username"]
+ removed = client.delete(
+ "/api/vault/secrets/REST_LOGIN/fields/username",
+ json={"expected_updated_at": newer["secret"]["updated_at"]}, headers=headers,
+ )
+ assert removed.status_code == 200
+ assert removed.get_json()["secret"]["fields"] == ["value"]
+
+
+def test_rest_field_routes_reject_plaintext_and_default_delete(monkeypatch):
+ seal = Mock(return_value=_sealed())
+ monkeypatch.setattr(api, "avault_seal_blind_box", seal)
+ api.create_vault_secret(
+ {
+ "name": "REST_LOGIN",
+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "default"},
+ }
+ )
+ client = app.test_client()
+ headers = csrf_headers(client)
+
+ rejected = client.put(
+ "/api/vault/secrets/REST_LOGIN/fields/password",
+ json={
+ "record": "REST_LOGIN.password",
+ "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "password"},
+ "nested": {"value": "plaintext"},
+ },
+ headers=headers,
+ )
+ assert rejected.status_code == 400
+ assert rejected.get_json()["code"] == "plaintext_value_rejected"
+ seal.assert_called_once()
+
+ default_delete = client.delete("/api/vault/secrets/REST_LOGIN/fields/value", headers=headers)
+ assert default_delete.status_code == 409
+ assert default_delete.get_json()["code"] == "invalid_request"
diff --git a/tests/test_vault_schema.py b/tests/test_vault_schema.py
index 0ae88b123..291d1ac1f 100644
--- a/tests/test_vault_schema.py
+++ b/tests/test_vault_schema.py
@@ -1,9 +1,17 @@
from __future__ import annotations
-from sqlalchemy import text
+import json
+import sqlite3
+from pathlib import Path
+
+import pytest
+from alembic import command
+from sqlalchemy import inspect, text
from storage.db import create_sqlite_engine
+from storage import migrations
from storage.models import metadata
+from tests.test_sqlite_state_migration import _Pre335Connection
_VAULT_TABLES = ("vault_secrets", "vault_requests", "vault_grants", "vault_audit")
@@ -20,7 +28,7 @@ def test_vault_metadata_schema_matches_grant_id_tag_model(tmp_path):
assert "vault_links" not in tables
secret_cols = {row[1] for row in conn.execute(text("pragma table_info(vault_secrets)"))}
- assert {"name", "tags", "kind", "protection", "ciphertext", "nonce", "wrap_meta"} <= secret_cols
+ assert {"name", "tags", "kind", "protection", "ciphertext", "nonce", "wrap_meta", "fields"} <= secret_cols
assert "group_name" not in secret_cols
secret_indexes = {row[1] for row in conn.execute(text("select seq, name from pragma_index_list('vault_secrets')"))}
assert "uq_vault_secrets_name_folded" in secret_indexes
@@ -47,3 +55,125 @@ def test_vault_metadata_schema_matches_grant_id_tag_model(tmp_path):
} <= grant_cols
assert "scope_type" not in grant_cols
assert "scope_ref" not in grant_cols
+
+
+def test_vault_fields_migration_round_trip_preserves_old_rows(tmp_path: Path, monkeypatch):
+ db_path = tmp_path / "vault_migration.sqlite"
+ migrations.run_migrations(db_path, revision="20261012_0064")
+
+ with sqlite3.connect(db_path) as conn:
+ conn.execute(
+ """
+ insert into vault_secrets (
+ id, name, kind, protection, source, ciphertext, nonce, wrap_meta,
+ public_meta, use_count, created_at, updated_at
+ ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ """,
+ (
+ "vlt_old",
+ "OLD_SECRET",
+ "static",
+ "standard",
+ "manual",
+ "ct-old",
+ "n-old",
+ "wm-old",
+ json.dumps({"description": "legacy"}),
+ 0,
+ "2026-10-13T00:00:00+00:00",
+ "2026-10-13T00:00:00+00:00",
+ ),
+ )
+ cursor = conn.execute("select * from vault_secrets where id = ?", ("vlt_old",))
+ original_row = cursor.fetchone()
+ original_columns = ", ".join(column[0] for column in cursor.description)
+ conn.commit()
+
+ migrations.run_migrations(db_path)
+ with sqlite3.connect(db_path) as conn:
+ columns = {row[1] for row in conn.execute("pragma table_info(vault_secrets)")}
+ row = conn.execute(
+ "select name, ciphertext, public_meta, fields from vault_secrets where id = ?",
+ ("vlt_old",),
+ ).fetchone()
+ assert "fields" in columns
+ assert row == ("OLD_SECRET", "ct-old", json.dumps({"description": "legacy"}), None)
+
+ real_connect = sqlite3.connect
+
+ def legacy_connect(*args, **kwargs):
+ kwargs["factory"] = _Pre335Connection
+ return real_connect(*args, **kwargs)
+
+ monkeypatch.setattr(sqlite3, "connect", legacy_connect)
+ monkeypatch.setattr(sqlite3.dbapi2, "connect", legacy_connect)
+ command.downgrade(migrations.alembic_config(db_path), "20261012_0064")
+ with sqlite3.connect(db_path) as conn:
+ columns = {row[1] for row in conn.execute("pragma table_info(vault_secrets)")}
+ row = conn.execute(
+ "select name, ciphertext, public_meta from vault_secrets where id = ?",
+ ("vlt_old",),
+ ).fetchone()
+ assert "fields" not in columns
+ assert row == ("OLD_SECRET", "ct-old", json.dumps({"description": "legacy"}))
+ assert conn.execute(
+ f"select {original_columns} from vault_secrets where id = ?", ("vlt_old",)
+ ).fetchone() == original_row
+ indexes = {row[1] for row in conn.execute("pragma index_list(vault_secrets)")}
+ assert {"ix_vault_secrets_name_kind", "uq_vault_secrets_name_folded"} <= indexes
+ assert [row[2] for row in conn.execute("pragma index_info(ix_vault_secrets_name_kind)")] == ["name", "kind"]
+ conn.execute(
+ "insert into vault_secrets (id, name, created_at, updated_at) values ('vlt_other', 'OTHER', 'now', 'now')"
+ )
+ for duplicate in ("OLD_SECRET", "old_secret"):
+ with pytest.raises(sqlite3.IntegrityError, match="UNIQUE constraint failed"):
+ conn.execute(
+ "insert into vault_secrets (id, name, created_at, updated_at) values (?, ?, 'now', 'now')",
+ (f"vlt_duplicate_{duplicate}", duplicate),
+ )
+ assert conn.execute("pragma integrity_check").fetchone() == ("ok",)
+ engine = create_sqlite_engine(db_path)
+ try:
+ assert {"name": "uq_vault_secrets_name", "column_names": ["name"]} in inspect(engine).get_unique_constraints("vault_secrets")
+ finally:
+ engine.dispose()
+
+
+def test_head_repair_adds_missing_fields_column_without_dropping_rows(tmp_path: Path):
+ db_path = tmp_path / "vault_repair.sqlite"
+ engine = create_sqlite_engine(db_path)
+ metadata.create_all(engine)
+ engine.dispose()
+ with sqlite3.connect(db_path) as conn:
+ conn.execute('alter table "vault_secrets" drop column "fields"')
+ conn.execute(
+ """
+ insert into vault_secrets (
+ id, name, kind, protection, source, ciphertext, nonce, wrap_meta,
+ use_count, created_at, updated_at
+ ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ """,
+ (
+ "vlt_repair",
+ "REPAIR_SECRET",
+ "static",
+ "standard",
+ "manual",
+ "ct-repair",
+ "n-repair",
+ "wm-repair",
+ 0,
+ "2026-10-13T00:00:00+00:00",
+ "2026-10-13T00:00:00+00:00",
+ ),
+ )
+ conn.commit()
+ assert migrations.background_tables_ready(db_path) is False
+ migrations.run_migrations(db_path)
+ assert migrations.background_tables_ready(db_path) is True
+ with sqlite3.connect(db_path) as conn:
+ assert "fields" in {row[1] for row in conn.execute("pragma table_info(vault_secrets)")}
+ assert conn.execute(
+ "select name, ciphertext, fields from vault_secrets where id = ?",
+ ("vlt_repair",),
+ ).fetchone() == ("REPAIR_SECRET", "ct-repair", None)
diff --git a/tests/test_vault_service.py b/tests/test_vault_service.py
index e14359784..ea811a3b4 100644
--- a/tests/test_vault_service.py
+++ b/tests/test_vault_service.py
@@ -17,6 +17,7 @@ from storage.models import (
agent_sessions,
metadata,
state_meta,
+ vault_audit,
vault_auth_factors,
vault_grants,
vault_requests,
@@ -97,6 +98,10 @@ def test_secret_metadata_is_global_name_plus_tags(vault):
assert meta["tags"] == ["prod", "skill:deploy"]
assert "group" not in meta
assert "preview" not in meta
+ assert meta["default_field"] == "value"
+ assert meta["fields"] == ["value"]
+ assert meta["last_used_at"] is None
+ assert meta["policy"] == {}
with vault.connect() as conn:
row = conn.execute(select(vault_secrets).where(vault_secrets.c.name == "OPENAI_API_KEY")).mappings().one()
@@ -327,6 +332,538 @@ def test_skill_links_are_stored_as_skill_tags(vault):
assert meta["tags"] == ["github", "skill:github-release"]
+ "value",
+ ["", "value ", " value", "Value", "value-name", "value.name", "a" * 65, None],
+)
+def test_validate_field_name_is_strict(value):
+ with pytest.raises(vs.InvalidFieldNameError):
+ vs.validate_field_name(value)
+
+
+def test_provision_field_spec_contains_only_valid_distinct_labels():
+ assert vs.normalize_provision_spec({"fields": ["username", "password"]}) == {
+ "fields": ["username", "password"], "default_field": "username",
+ }
+ assert vs.normalize_provision_spec({
+ "fields": ["username", "password"], "default_field": "password",
+ })["default_field"] == "password"
+ for invalid in [
+ {"default_field": "password"},
+ {"fields": []},
+ {"fields": ["password", "password"]},
+ {"fields": ["username"], "default_field": "password"},
+ {"fields": ["password "]},
+ {"fields": [{"name": "password", "value": "plaintext"}]},
+ ]:
+ with pytest.raises(vs.VaultServiceError):
+ vs.normalize_provision_spec(invalid)
+
+
+def test_fields_use_canonical_records_and_default_label_fallback(vault):
+ _create(
+ vault,
+ name="lowerSecret",
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+
+ with vault.begin() as conn:
+ meta = vs.get_secret_meta(conn, "lowerSecret")
+ default_ref = vs.get_secret_record_meta(conn, "lowerSecret.password")
+ extra_ref = vs.get_secret_record_meta(conn, "lowerSecret.username")
+
+ assert meta["default_field"] == "password"
+ assert meta["fields"] == ["password", "username"]
+ assert vs.secret_record_names(meta) == ["lowerSecret", "lowerSecret.username"]
+ assert default_ref["record_name"] == "lowerSecret"
+ assert default_ref["field"] == "password"
+ assert extra_ref["record_name"] == "lowerSecret.username"
+ assert all(key not in json.dumps(meta) for key in ("ciphertext", "nonce", "wrap_meta"))
+ assert vs.get_envelope(conn, "lowerSecret") == _sealed("lowersecret")
+ assert vs.get_envelope(conn, "lowerSecret.username") == _sealed("username")
+
+ conn.execute(
+ vault_secrets.update()
+ .where(vault_secrets.c.name == "lowerSecret")
+ .values(public_meta=json.dumps({"default_field": "INVALID"}))
+ )
+ assert vs.get_secret_meta(conn, "lowerSecret")["default_field"] == "value"
+
+
[email protected]("protection", ["standard", "protected"])
+def test_default_rename_is_metadata_only_and_collision_safe(vault, protection):
+ _create(
+ vault,
+ name="LOGIN",
+ protection=protection,
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ policy={"always_ask": True},
+ )
+
+ with vault.begin() as conn:
+ request = vs.create_access_request(conn, "LOGIN")
+ grant = _grant_from_request(conn, request)
+ pending = vs.create_access_request(conn, "LOGIN")
+ pending_versions = pending["card"]["grant_options"][0]["member_versions"]
+ before = vs.get_secret_meta(conn, "LOGIN")
+ get_envelope = vs.get_protected_envelope if protection == "protected" else vs.get_envelope
+ default_envelope = get_envelope(conn, "LOGIN")
+ renamed = vs.update_secret_metadata(conn, "LOGIN", default_field="credential")
+ after = vs.get_secret_meta(conn, "LOGIN")
+
+ assert renamed["default_field"] == "credential"
+ assert renamed["fields"] == ["credential", "username"]
+ assert renamed["policy"] == {"always_ask": True}
+ assert after["updated_at"] == before["updated_at"]
+ hydrated = vs.get_request(conn, pending["id"])
+ assert hydrated["status"] == "pending"
+ assert hydrated["card"]["grant_options"][0]["member_versions"] == pending_versions
+ assert hydrated["card"]["grant_options"][0]["member_fields"] == [
+ {"name": "LOGIN", "kind": "static", "default_field": "credential", "fields": ["credential", "username"]}
+ ]
+ # The persisted authorization snapshot is unchanged; only its UI projection is current.
+ stored = conn.execute(select(vault_requests.c.delivery).where(vault_requests.c.id == pending["id"])).scalar_one()
+ assert json.loads(stored)["card"]["grant_options"][0]["member_fields"][0]["default_field"] == "password"
+ assert _grant_from_request(conn, pending)["status"] == "active"
+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "active"
+ assert get_envelope(conn, "LOGIN") == default_envelope
+ with pytest.raises(vs.RecordMismatchError):
+ vs.update_secret_field(
+ conn, "LOGIN", "password", _sealed("stale-default"), record="LOGIN",
+ expected_updated_at=before["updated_at"],
+ )
+ with pytest.raises(vs.FieldExistsError):
+ vs.update_secret_metadata(conn, "LOGIN", default_field="username")
+ assert get_envelope(conn, "LOGIN") == default_envelope
+
+
[email protected]("malformed", ["invalid_json", "non_array", "bad_entry", "duplicate", "default_collision"])
[email protected]("protection", ["standard", "protected"])
+def test_corrupt_fields_disable_mutations_without_losing_bytes(vault, caplog, malformed, protection):
+ _create(vault, name="LOGIN", protection=protection, fields=[{"name": "username", "sealed": _sealed("username")}])
+ with vault.begin() as conn:
+ stored = conn.execute(select(vault_secrets.c.fields).where(vault_secrets.c.name == "LOGIN")).scalar_one()
+ valid = json.loads(stored)
+ damaged = {
+ "invalid_json": '{"unparseable":',
+ "non_array": '{"name":"username"}',
+ "bad_entry": json.dumps([*valid, {"name": "password", "ciphertext": "must-not-disappear"}]),
+ "duplicate": json.dumps([*valid, valid[0]]),
+ "default_collision": json.dumps([*valid, {**valid[0], "name": "value"}]),
+ }[malformed]
+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "LOGIN").values(fields=damaged))
+ caplog.clear()
+ meta = vs.get_secret_meta(conn, "LOGIN")
+ assert meta["fields"] == ["value"]
+ assert meta["fields_state"] == "corrupt"
+ assert vs.list_secrets(conn)[0]["fields_state"] == "corrupt"
+ get_envelope = vs.get_protected_record_envelope if protection == "protected" else vs.get_envelope
+ assert get_envelope(conn, "LOGIN") == _sealed("login")
+ assert get_envelope(conn, "LOGIN.value") == _sealed("login")
+ assert sum("corrupt fields" in entry.message.lower() for entry in caplog.records) == 1
+ assert "must-not-disappear" not in caplog.text
+ before = dict(conn.execute(select(vault_secrets).where(vault_secrets.c.name == "LOGIN")).mappings().one())
+ with pytest.raises(vs.FieldsCorruptError):
+ get_envelope(conn, "LOGIN.username")
+ operations = [
+ lambda: vs.update_secret_field(conn, "LOGIN", "totp", _sealed("new"), record="LOGIN.totp"),
+ lambda: vs.update_secret_field(conn, "LOGIN", "username", _sealed("new"), record="LOGIN.username"),
+ lambda: vs.update_secret_field(conn, "LOGIN", "value", _sealed("new"), record="LOGIN"),
+ lambda: vs.remove_secret_field(conn, "LOGIN", "username"),
+ lambda: vs.update_secret_metadata(conn, "LOGIN", default_field="password"),
+ lambda: vs.rotate_secret(conn, "LOGIN", _sealed("new")),
+ ]
+ for operation in operations:
+ with pytest.raises(vs.FieldsCorruptError):
+ operation()
+ after = dict(conn.execute(select(vault_secrets).where(vault_secrets.c.name == "LOGIN")).mappings().one())
+ assert after == before
+ assert after["fields"] == damaged
+ assert not list(conn.execute(select(vault_audit.c.id).where(vault_audit.c.event == "updated")))
+
+
+def test_ordinary_metadata_preserves_approval_and_policy_edits_expire_it(vault):
+ _create(
+ vault, name="LOGIN", protection="protected", description="old",
+ policy={"always_ask": True, "allowed_hosts": ["example.com"]},
+ )
+ with vault.begin() as conn:
+ before = vs.get_secret_meta(conn, "LOGIN")
+ request = vs.create_access_request(conn, "LOGIN")
+ edited = vs.update_secret_metadata(conn, "LOGIN", description="new", tags=["new"])
+ assert edited["updated_at"] == before["updated_at"]
+ hydrated = vs.get_request(conn, request["id"])
+ assert hydrated["card"]["grant_options"][0]["unlock_material"][0]["name"] == "LOGIN"
+ grant = _grant_from_request(conn, request)
+ scopes = []
+ updated = vs.update_secret_metadata(
+ conn, "LOGIN", policy={"allowed_hosts": ["new.example.com"]}, release_scopes=scopes,
+ )
+ assert updated["policy"] == {"always_ask": True, "allowed_hosts": ["new.example.com"]}
+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "expired"
+ assert scopes == [{"grant_id": grant["id"]}]
+
+
[email protected]("operation", ["add", "replace_default", "replace_extra", "remove"])
+def test_field_write_cas_without_explicit_version_has_no_conflict_side_effects(vault, monkeypatch, operation):
+ _create(
+ vault, name="LOGIN", protection="protected",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ with vault.begin() as conn:
+ grant = _grant_from_request(conn, vs.create_access_request(conn, "LOGIN"))
+ pending = vs.create_access_request(conn, "LOGIN")
+
+ require_management = vs._require_secret_resource_management
+ raced = False
+
+ def write_after_snapshot(conn, row, context):
+ nonlocal raced
+ snapshot = require_management(conn, row, context)
+ if not raced:
+ raced = True
+ with vault.begin() as winner:
+ vs.update_secret_field(winner, "LOGIN", "other", _sealed("winner"), record="LOGIN.other")
+ return snapshot
+
+ monkeypatch.setattr(vs, "_require_secret_resource_management", write_after_snapshot)
+ release_scopes = []
+ with vault.begin() as conn:
+ with pytest.raises(vs.SecretConflictError):
+ if operation == "remove":
+ vs.remove_secret_field(conn, "LOGIN", "username", release_scopes=release_scopes)
+ else:
+ field = {"add": "totp", "replace_default": "value", "replace_extra": "username"}[operation]
+ record = "LOGIN" if field == "value" else f"LOGIN.{field}"
+ vs.update_secret_field(conn, "LOGIN", field, _sealed("loser"), record=record, release_scopes=release_scopes)
+ assert vs.get_secret_meta(conn, "LOGIN")["fields"] == ["value", "username", "other"]
+ assert vs.get_protected_envelope(conn, "LOGIN") == _sealed("login")
+ assert vs.get_protected_envelope(conn, "LOGIN.username") == _sealed("username")
+ assert vs.get_protected_envelope(conn, "LOGIN.other") == _sealed("winner")
+ # Only the winning write changed authorization and produced a field audit.
+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "expired"
+ assert vs.get_request(conn, pending["id"])["status"] == "expired"
+ assert vs.GRANT_RUNTIME_CACHE.covered_names(grant["id"]) == []
+ updates = list(conn.execute(select(vault_audit.c.delivery).where(vault_audit.c.event == "updated")).scalars())
+ assert [json.loads(payload)["field"] for payload in updates] == ["other"]
+ assert release_scopes == []
+
+
[email protected]("field,record", [("value", "LOGIN"), ("password", "LOGIN.password")])
+def test_protected_field_write_rejects_rename_after_record_resolution(vault, monkeypatch, field, record):
+ _create(vault, name="LOGIN", protection="protected")
+ with vault.begin() as conn:
+ grant = _grant_from_request(conn, vs.create_access_request(conn, "LOGIN"))
+ pending = vs.create_access_request(conn, "LOGIN")
+ before = vs.get_secret_meta(conn, "LOGIN")
+ original = vs._require_secret_resource_management
+ raced = False
+
+ def rename_after_snapshot(conn, row, context):
+ nonlocal raced
+ snapshot = original(conn, row, context)
+ if not raced:
+ raced = True
+ with vault.begin() as winner:
+ vs.update_secret_metadata(winner, "LOGIN", default_field="password")
+ return snapshot
+
+ monkeypatch.setattr(vs, "_require_secret_resource_management", rename_after_snapshot)
+ release_scopes = []
+ with vault.begin() as conn:
+ with pytest.raises(vs.RecordMismatchError):
+ vs.update_secret_field(conn, "LOGIN", field, _sealed("loser"), record=record, release_scopes=release_scopes)
+ assert vs.get_protected_envelope(conn, "LOGIN") == _sealed("login")
+ after = vs.get_secret_meta(conn, "LOGIN")
+ assert after["updated_at"] == before["updated_at"]
+ assert after["fields"] == ["password"]
+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "active"
+ assert vs.get_request(conn, pending["id"])["status"] == "pending"
+ assert release_scopes == []
+
+
[email protected]("operation", ["rename", "pin", "rotate"])
+def test_metadata_writers_do_not_overwrite_a_concurrent_description(vault, monkeypatch, operation):
+ _create(vault, name="LOGIN", description="old")
+ original = vs._require_secret_resource_management
+ raced = False
+
+ def edit_after_snapshot(conn, row, context):
+ nonlocal raced
+ snapshot = original(conn, row, context)
+ if not raced:
+ raced = True
+ with vault.begin() as winner:
+ vs.update_secret_metadata(winner, "LOGIN", description="concurrent")
+ return snapshot
+
+ monkeypatch.setattr(vs, "_require_secret_resource_management", edit_after_snapshot)
+ with vault.begin() as conn:
+ with pytest.raises(vs.SecretConflictError):
+ if operation == "rename":
+ vs.update_secret_metadata(conn, "LOGIN", default_field="password")
+ elif operation == "pin":
+ vs.store_pubkey_pin(conn, "LOGIN", {"public_key": "public", "fingerprint": "fingerprint"})
+ else:
+ vs.rotate_secret(conn, "LOGIN", _sealed("loser"))
+ assert vs.get_secret_meta(conn, "LOGIN")["description"] == "concurrent"
+ assert vs.get_envelope(conn, "LOGIN") == _sealed("login")
+
+
+def test_field_writes_replace_add_remove_with_versioned_cas(vault):
+ _create(vault, name="LOGIN")
+
+ with vault.begin() as conn:
+ original = vs.get_secret_meta(conn, "LOGIN")
+ added = vs.update_secret_field(
+ conn,
+ "LOGIN",
+ "username",
+ _sealed("username"),
+ record="LOGIN.username",
+ expected_updated_at=original["updated_at"],
+ )
+ replaced = vs.update_secret_field(
+ conn,
+ "LOGIN",
+ "value",
+ _sealed("replacement"),
+ record="LOGIN",
+ expected_updated_at=added["updated_at"],
+ )
+
+ assert replaced["updated_at"] > added["updated_at"]
+ assert vs.get_envelope(conn, "LOGIN") == _sealed("replacement")
+ with pytest.raises(vs.SecretConflictError):
+ vs.update_secret_field(
+ conn,
+ "LOGIN",
+ "username",
+ _sealed("stale"),
+ record="LOGIN.username",
+ expected_updated_at=original["updated_at"],
+ )
+ assert vs.get_secret_meta(conn, "LOGIN")["fields"] == ["value", "username"]
+
+ removed = vs.remove_secret_field(
+ conn,
+ "LOGIN",
+ "username",
+ expected_updated_at=replaced["updated_at"],
+ )
+ assert removed["fields"] == ["value"]
+ assert removed["updated_at"] > replaced["updated_at"]
+ with pytest.raises(vs.SecretConflictError):
+ vs.remove_secret_field(
+ conn,
+ "LOGIN",
+ "username",
+ expected_updated_at=replaced["updated_at"],
+ )
+
+
+def test_field_limits_duplicates_and_version_monotonicity(vault):
+ with vault.begin() as conn:
+ with pytest.raises(vs.VaultServiceError, match="fields must be an array"):
+ vs.create_secret(conn, name="INVALID", sealed=_sealed(), fields={})
+ with pytest.raises(vs.FieldsNotSupportedError):
+ vs.create_secret(
+ conn, name="INVALID", sealed=_sealed(), kind="keypair",
+ fields=[{"name": "username", "sealed": _sealed()}],
+ )
+ for names in [["password"], ["username", "username"]]:
+ with pytest.raises(vs.FieldExistsError):
+ vs.create_secret(
+ conn, name="INVALID", sealed=_sealed(), default_field="password",
+ fields=[{"name": name, "sealed": _sealed()} for name in names],
+ )
+ with pytest.raises(vs.TooManyFieldsError):
+ vs.create_secret(
+ conn, name="INVALID", sealed=_sealed(),
+ fields=[{"name": f"field{i}", "sealed": _sealed()} for i in range(32)],
+ )
+ vs.create_secret(
+ conn, name="LOGIN", sealed=_sealed(),
+ fields=[{"name": f"field{i}", "sealed": _sealed()} for i in range(31)],
+ )
+ with pytest.raises(vs.TooManyFieldsError):
+ vs.update_secret_field(conn, "LOGIN", "overflow", _sealed(), record="LOGIN.overflow")
+ with pytest.raises(vs.InvalidRequestError, match="default field"):
+ vs.remove_secret_field(conn, "LOGIN", "value")
+ with pytest.raises(vs.FieldNotFoundError, match="fields: value, field0"):
+ vs.get_envelope(conn, "LOGIN.unknown")
+ # A persisted future timestamp models a clock that moved backwards.
+ future = "2100-01-01T00:00:00+00:00"
+ conn.execute(vault_secrets.update().where(vault_secrets.c.name == "LOGIN").values(updated_at=future))
+ replaced = vs.update_secret_field(conn, "LOGIN", "field0", _sealed("replacement"), record="LOGIN.field0")
+ assert replaced["updated_at"] == "2100-01-01T00:00:00.000001+00:00"
+ removed = vs.remove_secret_field(conn, "LOGIN", "field0")
+ assert removed["updated_at"] == "2100-01-01T00:00:00.000002+00:00"
+ assert vs.get_envelope(conn, "LOGIN.field1") == _sealed()
+
+
+def test_keypair_field_refs_and_mutations_are_rejected(vault):
+ _create(vault, name="SIGNING_KEY", kind="keypair", signer_kind="local")
+
+ with vault.begin() as conn:
+ with pytest.raises(vs.FieldsNotSupportedError):
+ vs.get_secret_record_meta(conn, "SIGNING_KEY.value")
+ with pytest.raises(vs.FieldsNotSupportedError):
+ vs.update_secret_field(conn, "SIGNING_KEY", "value", _sealed("replacement"), record="SIGNING_KEY")
+ with pytest.raises(vs.FieldsNotSupportedError):
+ vs.remove_secret_field(conn, "SIGNING_KEY", "value")
+
+
+def test_selector_records_preserve_secret_case_and_reject_empty_alias(vault):
+ _create(
+ vault,
+ name="lowerSecret",
+ protection="protected",
+ tags=["deploy"],
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+
+ with vault.begin() as conn:
+ expanded = vs.expand_value_delivery_selector(conn, env=["lowerSecret.username"])
+ assert expanded["secrets"] == [
+ {
+ "name": "lowerSecret",
+ "field": "username",
+ "record": "lowerSecret.username",
+ "env": "lowerSecret_USERNAME",
+ "kind": "static",
+ "protection": "protected",
+ }
+ ]
+ tagged = vs.expand_value_delivery_selector(conn, tags=["deploy"])
+ assert [item["env"] for item in tagged["secrets"]] == [
+ "lowerSecret",
+ "lowerSecret_USERNAME",
+ ]
+ with pytest.raises(vs.InvalidRequestError):
+ vs.expand_value_delivery_selector(conn, env=["=lowerSecret"])
+ default_ref = vs.expand_value_delivery_selector(conn, env=["lowerSecret.value"])
+ assert default_ref["secrets"][0]["record"] == "lowerSecret"
+ assert default_ref["secrets"][0]["env"] == "lowerSecret_VALUE"
+ for conflict in [
+ ["lowerSecret", "lowerSecret.value"],
+ ["SAME=lowerSecret", "SAME=lowerSecret.username"],
+ ]:
+ with pytest.raises(vs.InvalidRequestError):
+ vs.expand_value_delivery_selector(conn, env=conflict)
+
+
+def test_access_request_deduplicates_secret_members_and_exposes_field_metadata(vault):
+ _create(
+ vault,
+ name="PROTECTED_LOGIN",
+ protection="protected",
+ default_field="password",
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+
+ with vault.begin() as conn:
+ request = vs.create_access_request(
+ conn,
+ source_selector={"env": ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]},
+ )
+ option = request["card"]["grant_options"][0]
+ assert option["member_snapshot"] == ["PROTECTED_LOGIN"]
+ assert option["member_fields"] == [
+ {
+ "name": "PROTECTED_LOGIN",
+ "kind": "static",
+ "default_field": "password",
+ "fields": ["password", "username"],
+ }
+ ]
+ assert [item["name"] for item in option["unlock_material"]] == [
+ "PROTECTED_LOGIN",
+ "PROTECTED_LOGIN.username",
+ ]
+ assert request["card"]["secret_unlock_material"] == {
+ "name": "PROTECTED_LOGIN",
+ "kind": "static",
+ "envelope": {
+ "ciphertext": "ct-protected_login",
+ "nonce": "n-protected_login",
+ "wrap_meta": "wm-protected_login",
+ },
+ }
+ agent_payload = vs.get_request(conn, request["id"], audience=vs.REQUEST_AUDIENCE_AGENT)
+ persisted = json.loads(conn.execute(
+ select(vault_requests.c.delivery).where(vault_requests.c.id == request["id"])
+ ).scalar_one())
+ for payload in [agent_payload, persisted]:
+ encoded = json.dumps(payload)
+ assert "ciphertext" not in encoded
+ assert "unlock_material" not in encoded
+ assert payload["card"]["grant_options"][0]["member_fields"] == option["member_fields"]
+ # Legacy binding issues one approval per record. Retain the default
+ # approval while the next field receives its own release context.
+ for name in ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]:
+ recorded = vs.record_request_agent_binding_approvals(
+ conn, request["id"],
+ {"grant_id": option["grant_id"], "items": [{"name": name}]},
+ )
+ assert [
+ item["items"][0]["name"]
+ for item in recorded["delivery"]["agent_binding_approvals"]
+ ] == ["PROTECTED_LOGIN", "PROTECTED_LOGIN.username"]
+ grant = _grant_from_request(conn, request)
+ resolved = vs.resolve_secret_access(conn, "PROTECTED_LOGIN.username")
+ assert resolved["grant"]["member_snapshot"] == ["PROTECTED_LOGIN"]
+ assert resolved["envelope"] == _sealed("username")
+ scopes = []
+ vs.update_secret_field(conn, "PROTECTED_LOGIN", "username", _sealed("new"), record="PROTECTED_LOGIN.username", release_scopes=scopes)
+ assert vs.get_grant_created_by_request(conn, grant["request_id"])["status"] == "expired"
+ assert scopes == [{"grant_id": grant["id"]}]
+ next_grant = _grant_from_request(conn, vs.create_access_request(conn, "PROTECTED_LOGIN"))
+ pending = vs.create_access_request(conn, "PROTECTED_LOGIN")
+ scopes.clear()
+ vs.remove_secret_field(conn, "PROTECTED_LOGIN", "username", release_scopes=scopes)
+ assert vs.get_request(conn, pending["id"])["status"] == "expired"
+ assert vs.get_grant_created_by_request(conn, next_grant["request_id"])["status"] == "expired"
+ assert scopes == [{"grant_id": next_grant["id"]}]
+
+
+def test_standard_ask_card_persists_fields_and_field_access_uses_secret_members(vault):
+ _create(
+ vault, name="LOGIN", policy={"always_ask": True},
+ fields=[{"name": "username", "sealed": _sealed("username")}],
+ )
+ with vault.begin() as conn:
+ request = vs.create_access_request(conn, "LOGIN.username", audience=vs.REQUEST_AUDIENCE_AGENT)
+ option = request["card"]["grant_options"][0]
+ assert request["secret_name"] == "LOGIN"
+ assert option["member_snapshot"] == ["LOGIN"]
+ assert option["member_fields"] == [
+ {"name": "LOGIN", "kind": "static", "default_field": "value", "fields": ["value", "username"]}
+ ]
+ assert "unlock_material" not in json.dumps(request)
+
+
+def test_delivery_use_count_is_per_secret_and_audit_lists_fields(vault):
+ _create(vault, name="LOGIN", fields=[{"name": "username", "sealed": _sealed("username")}])
+
+ with vault.begin() as conn:
+ identities = vs.capture_delivery_identities(conn, ["LOGIN", "LOGIN.username"])
+ vs.record_deliveries(conn, identities, mode="run")
+ meta = vs.get_secret_meta(conn, "LOGIN")
+ events = conn.execute(
+ select(vs.vault_audit.c.delivery).where(
+ vs.vault_audit.c.secret_name == "LOGIN",
+ vs.vault_audit.c.event == "delivered",
+ )
+ ).scalars().all()
+
+ assert meta["use_count"] == 1
+ assert len(events) == 1
+ assert json.loads(events[0])["fields"] == ["value", "username"]
+
+
def test_selector_expansion_unions_env_tags_and_skills(vault):
_create(vault, name="A_KEY", protection="protected", tags=["deploy"])
_create(vault, name="B_KEY", protection="standard", tags=["deploy", "skill:release"])
@@ -342,9 +879,30 @@ def test_selector_expansion_unions_env_tags_and_skills(vault):
assert expanded["source_selector"] == {"env": ["LOCAL_C=C_KEY"], "tags": ["deploy", "skill:release"]}
assert expanded["secrets"] == [
- {"name": "C_KEY", "env": "LOCAL_C", "kind": "static", "protection": "standard"},
- {"name": "A_KEY", "env": "A_KEY", "kind": "static", "protection": "protected"},
- {"name": "B_KEY", "env": "B_KEY", "kind": "static", "protection": "standard"},
+ {
+ "name": "C_KEY",
+ "field": "value",
+ "record": "C_KEY",
+ "env": "LOCAL_C",
+ "kind": "static",
+ "protection": "standard",
+ },
+ {
+ "name": "A_KEY",
+ "field": "value",
+ "record": "A_KEY",
+ "env": "A_KEY",
+ "kind": "static",
+ "protection": "protected",
+ },
+ {
+ "name": "B_KEY",
+ "field": "value",
+ "record": "B_KEY",
+ "env": "B_KEY",
+ "kind": "static",
+ "protection": "standard",
+ },
]
@@ -367,7 +925,14 @@ def test_selector_allows_shell_env_alias_for_secret(vault):
assert expanded["source_selector"] == {"env": ["api_key=PROTECTED_KEY"]}
assert expanded["secrets"] == [
- {"name": "PROTECTED_KEY", "env": "api_key", "kind": "static", "protection": "protected"}
+ {
+ "name": "PROTECTED_KEY",
+ "field": "value",
+ "record": "PROTECTED_KEY",
+ "env": "api_key",
+ "kind": "static",
+ "protection": "protected",
+ }
]
diff --git a/tests/test_web_push_provider_invalidation_migration.py b/tests/test_web_push_provider_invalidation_migration.py
index f10c9e9ce..ad7f9f8b1 100644
--- a/tests/test_web_push_provider_invalidation_migration.py
+++ b/tests/test_web_push_provider_invalidation_migration.py
@@ -69,7 +69,7 @@ def test_upgrade_keeps_legacy_disabled_failure_opted_out(tmp_path):
web_push_service.mark_send_failure(conn, endpoint=enabled["endpoint"], disable=True)
with sqlite3.connect(path) as conn:
assert conn.execute("select version_num from alembic_version").fetchone() == (
- "20261012_0064",
+ "20261013_0065",
)
command.downgrade(migrations.alembic_config(path), "20260907_0061")
diff --git a/ui/src/components/ui/vault-approval-card.test.tsx b/ui/src/components/ui/vault-approval-card.test.tsx
index 01f9e996e..8aab6f8c8 100644
--- a/ui/src/components/ui/vault-approval-card.test.tsx
+++ b/ui/src/components/ui/vault-approval-card.test.tsx
@@ -121,6 +121,43 @@ const approveWhenReady = async () => {
// placeholder, and a refresh during the release supersedes the contexts it is releasing. The
// VaultsPage reveal tests cover only the reveal context, not these binding contexts.
describe('VaultApprovalCard protected access approval', () => {
+ // Per-record DEKs must survive secret-level grouping. Single-record approvals do not catch
+ // deduplicating material by its base secret name or omitting standard always-ask field labels.
+ it.each(['protected', 'standard'] as const)('groups %s fields by secret and releases every protected record', async (protection) => {
+ const names = ['LOGIN', 'LOGIN.username', 'LOGIN.totp'];
+ const unlockMaterial = protection === 'protected' ? names.map((name) => ({ name, kind: 'static', envelope })) : [];
+ const request: VaultRequest = {
+ ...protectedAccess, secret_name: 'LOGIN',
+ card: {
+ request_type: 'access', protection, secret_names: ['LOGIN'],
+ protected_secret_names: protection === 'protected' ? ['LOGIN'] : [],
+ grant_options: [{
+ grant_id: 'grant_1', member_snapshot: ['LOGIN'], unlock_material: unlockMaterial,
+ member_fields: [{ name: 'LOGIN', default_field: 'password', fields: ['password', 'username', 'totp'] }],
+ }],
+ },
+ };
+ const batch = issuedFor(300);
+ api.createVaultAgentBindingsBatch.mockResolvedValue({
+ ...batch, items: names.map((name) => ({ ...batch.items[0], name })),
+ });
+ vault.approveProtectedRelease.mockResolvedValue(names.map(() => blindBox));
+ openWindow();
+ render(<I18nextProvider i18n={i18n}><VaultApprovalCard request={request} onResolved={vi.fn()} onCancel={vi.fn()} /></I18nextProvider>);
+ expect(screen.getByText('password · Default')).toBeTruthy();
+ expect(screen.getByText('username')).toBeTruthy();
+ expect(screen.getByText('totp')).toBeTruthy();
+ expect(screen.queryByText('LOGIN.username')).toBeNull();
+ if (protection === 'protected') {
+ await approveWhenReady();
+ await vi.waitFor(() => expect(api.fulfillVaultAccessRequest).toHaveBeenCalledOnce());
+ expect(vault.approveProtectedRelease.mock.calls[0][0].map((item: { material: { name: string } }) => item.material.name)).toEqual(names);
+ expect(api.fulfillVaultAccessRequest.mock.calls[0][1].deks.map((item: { name: string }) => item.name)).toEqual(names);
+ } else {
+ expect(api.createVaultAgentBindingsBatch).not.toHaveBeenCalled();
+ }
+ });
+
it.each([
{ approving: 'the remembered duration', remembered: 900, pick: null, duration: 900 },
{ approving: 'a duration picked on the card', remembered: 300, pick: /^15 min$/, duration: 900 },
@@ -157,7 +194,21 @@ describe('VaultApprovalCard protected access approval', () => {
expect(popup.close).toHaveBeenCalledOnce();
});
- // Contract: the approve button waits until the contexts for the duration it shows and the sandbox
+ it('shows a single custom field label in an access approval', () => {
+ const request: VaultRequest = {
+ ...protectedAccess,
+ card: {
+ request_type: 'access', protection: 'standard', secret_names: ['LOGIN'], protected_secret_names: [],
+ grant_options: [{
+ grant_id: 'grant_1', member_snapshot: ['LOGIN'], unlock_material: [],
+ member_fields: [{ name: 'LOGIN', default_field: 'password', fields: ['password'] }],
+ }],
+ },
+ };
+ render(<I18nextProvider i18n={i18n}><VaultApprovalCard request={request} onResolved={vi.fn()} onCancel={vi.fn()} /></I18nextProvider>);
+ expect(screen.getByText('password · Default')).toBeTruthy();
+ });
+
// client are ready, so a click never has to wait on either after opening the window. Without the
// wait (the regression), a click right after the card opens or the duration changes, or on a page
// whose sandbox client is still building, reaches the daemon or the sandbox only after the window
diff --git a/ui/src/components/ui/vault-approval-card.tsx b/ui/src/components/ui/vault-approval-card.tsx
index c6e0bd3d0..701ac7f4f 100644
--- a/ui/src/components/ui/vault-approval-card.tsx
+++ b/ui/src/components/ui/vault-approval-card.tsx
@@ -16,6 +16,7 @@ import { partitionTags } from '@/lib/vaultTags';
import { useProtectedVault, useVaultSandboxWarm, type ProtectedUnlockMaterial } from '@/lib/useProtectedVault';
import { openVaultsInBrowser, vaultPasskeyNeedsBrowser } from '@/lib/vaultBrowserHandoff';
import { vaultApprovalNeedsPasskey } from '@/lib/vaultRequestPlacement';
+import { vaultHasNamedFieldShape } from '@/lib/vaultFields';
import { usePreparedRequest } from '@/lib/usePreparedRequest';
import { openVaultAuthorizationWindow } from '@/lib/vaultSandboxClient';
import { SigningAddressList } from './signing-address-list';
@@ -54,6 +55,7 @@ type GrantOption = {
one_shot?: boolean;
member_count?: number;
member_snapshot?: string[];
+ member_fields?: Array<{ name: string; default_field: string; fields: string[] }>;
source_selector?: VaultSourceSelector;
/** Hydrated for UI audience: the protected members of this set to DEK-release. */
unlock_material?: ProtectedUnlockMaterial[];
@@ -162,7 +164,7 @@ export const VaultApprovalCard: React.FC<{
}, [card, isSign, option]);
// Protected secret names to be granted (design: "show the protected secret names covered").
const protectedNames = useMemo(() => {
- const materialNames = materials.map((m) => m.name);
+ const materialNames = [...new Set(materials.map((m) => m.name.split('.')[0]))];
return materialNames.length ? materialNames : (card?.protected_secret_names ?? []);
}, [card, materials]);
const isProtected = isSign ? card?.protection === 'protected' : protectedNames.length > 0 || card?.protection === 'protected';
@@ -460,6 +462,27 @@ export const VaultApprovalCard: React.FC<{
</Badge>
) : null}
</DetailRow>
+ {!isSign && memberNames.map((name) => {
+ const metadata = option?.member_fields?.find((member) => member.name === name);
+ const labels = metadata?.fields ?? materials
+ .filter((material) => material.name === name || material.name.startsWith(`${name}.`))
+ .map((material) => material.field ?? material.name.split('.')[1] ?? 'value');
+ const shape = metadata ?? {
+ kind: isKeypair ? 'keypair' : 'static',
+ default_field: labels[0] ?? 'value',
+ fields: labels,
+ };
+ if (isKeypair || !vaultHasNamedFieldShape(shape)) return null;
+ return (
+ <DetailRow key={name} label={name}>
+ {labels.map((field) => (
+ <Badge key={field} variant="outline" className="font-mono">
+ {field}{field === metadata?.default_field ? ` · ${t('vaults.fields.default')}` : ''}
+ </Badge>
+ ))}
+ </DetailRow>
+ );
+ })}
{isSign && hasSchemeAddress ? (
<DetailRow label={t('vaults.approval.signingAs')}>
<SigningAddressList addresses={schemeAddresses} />
diff --git a/ui/src/components/ui/vault-secret-dialog.tsx b/ui/src/components/ui/vault-secret-dialog.tsx
index 6c95d1aef..3c623cff5 100644
--- a/ui/src/components/ui/vault-secret-dialog.tsx
+++ b/ui/src/components/ui/vault-secret-dialog.tsx
@@ -23,7 +23,7 @@ export const VaultSecretDialog: React.FC<{
name?: string;
/** A pending provision request; spec / default protection / id are derived from it. */
request?: VaultRequest | null;
- /** An existing secret to edit (value-free metadata); mutually exclusive with create/provide. */
+ /** An existing secret to edit; mutually exclusive with create/provide. */
editSecret?: VaultSecret | null;
/** Start on the Protected tier even when a provision request defaults to Standard: a browser
* handoff carries the user's choice of Protected. It can only raise the tier, never lower it. */
diff --git a/ui/src/components/ui/vault-secret-fields-editor.test.tsx b/ui/src/components/ui/vault-secret-fields-editor.test.tsx
new file mode 100644
index 000000000..95dfb334f
--- /dev/null
+++ b/ui/src/components/ui/vault-secret-fields-editor.test.tsx
@@ -0,0 +1,536 @@
+// @vitest-environment jsdom
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { createInstance } from 'i18next';
+import { I18nextProvider, initReactI18next } from 'react-i18next';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { ApiError, type VaultSecret } from '@/context/ApiContext';
+import en from '@/i18n/en.json';
+import zh from '@/i18n/zh.json';
+import { VaultSecretFieldsEditor } from './vault-secret-fields-editor';
+
+const api = vi.hoisted(() => ({
+ updateVaultSecret: vi.fn(), updateVaultSecretField: vi.fn(), deleteVaultSecretField: vi.fn(),
+ listVaultSecrets: vi.fn(),
+ connectWorkbenchEvents: vi.fn(() => vi.fn()),
+ getVaultPubkey: vi.fn(async () => ({ public_key: 'public' })),
+}));
+const box = vi.hoisted(() => ({ scheme: 'test', enc: 'enc', ct: 'ciphertext' }));
+const sealBlindBox = vi.hoisted(() => vi.fn(async () => box));
+const vault = vi.hoisted(() => ({ status: 'unlocked', refresh: vi.fn(), sealValue: vi.fn() }));
+vi.mock('@/context/ApiContext', async (original) => ({
+ ...await original<typeof import('@/context/ApiContext')>(),
+ useApi: () => api,
+}));
+vi.mock('@/lib/useProtectedVault', () => ({ useProtectedVault: () => vault }));
+vi.mock('./vault-protected-unlock', () => ({ VaultProtectedUnlock: () => null }));
+vi.mock('@/lib/vaultCrypto', async (original) => ({
+ ...await original<typeof import('@/lib/vaultCrypto')>(), sealBlindBox,
+}));
+const i18n = createInstance();
+void i18n.use(initReactI18next).init({
+ lng: 'en', resources: { en: { translation: en }, zh: { translation: zh } }, interpolation: { escapeValue: false },
+});
+const secret: VaultSecret = {
+ name: 'LOGIN', default_field: 'password', fields: ['password', 'username'],
+ kind: 'static', protection: 'standard', signer_kind: null, source: 'user', tags: [],
+ policy: {}, last_used_at: null, use_count: 0, created_at: 'created', updated_at: 'version-1',
+};
+type EventHandlers = {
+ onConnected?: () => void;
+ onVaultsUpdated?: (data: { scope: string; secret_name?: string }) => void;
+};
+let eventHandlers: EventHandlers | null = null;
+const change = (label: string, value: string) => fireEvent.change(screen.getByLabelText(label), { target: { value } });
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ let reject!: (reason?: unknown) => void;
+ const promise = new Promise<T>((nextResolve, nextReject) => {
+ resolve = nextResolve;
+ reject = nextReject;
+ });
+ return { promise, resolve, reject };
+}
+const renderEditor = (entry = secret) => render(
+ <I18nextProvider i18n={i18n}><VaultSecretFieldsEditor secret={entry} disabled={false} onBusyChange={vi.fn()} /></I18nextProvider>,
+);
+beforeEach(() => {
+ api.updateVaultSecret.mockReset();
+ api.updateVaultSecretField.mockReset();
+ api.deleteVaultSecretField.mockReset();
+ api.listVaultSecrets.mockReset();
+ api.connectWorkbenchEvents.mockReset();
+ api.connectWorkbenchEvents.mockImplementation((handlers: EventHandlers) => {
+ eventHandlers = handlers;
+ return vi.fn();
+ });
+ api.updateVaultSecret.mockReset();
+ api.updateVaultSecretField.mockResolvedValue({ ok: true, secret: { ...secret, updated_at: 'version-2' } });
+ api.deleteVaultSecretField.mockReset();
+ api.listVaultSecrets.mockResolvedValue({ ok: true, secrets: [secret] });
+
+});
+afterEach(async () => { cleanup(); eventHandlers = null; vi.clearAllMocks(); await i18n.changeLanguage('en'); });
+
+// The editor owns metadata versions between browser encryptions. Form creation and crypto
+// tests cannot catch a second field write reusing the first version, or a default rename
+// accidentally turning its replacement into a dotted record.
+it('updates envelope versions after replacing a field and renaming the default label', async () => {
+ const rendered = renderEditor();
+ change('Value for password', 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledWith(
+ 'LOGIN', 'password', { record: 'LOGIN', blind_box: box, expected_updated_at: 'version-1' }, { handleError: false },
+ ));
+ await screen.findByRole('status');
+ expect((screen.getByLabelText('Value for password') as HTMLInputElement).value).toBe('');
+ // A parent poll can still hand back the old object after the child accepted its own
+ // successful write. The editor re-reads authoritative metadata instead of adopting it.
+ api.listVaultSecrets.mockResolvedValue({
+ ok: true,
+ secrets: [{ ...secret, updated_at: 'version-2' }],
+ });
+ rendered.rerender(
+ <I18nextProvider i18n={i18n}>
+ <VaultSecretFieldsEditor secret={{ ...secret }} disabled={false} onBusyChange={vi.fn()} />
+ </I18nextProvider>,
+ );
+ expect(screen.getByLabelText('Value for username')).toBeTruthy();
+ change('Value for username', 'next-user');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenLastCalledWith(
+ 'LOGIN', 'username', { record: 'LOGIN.username', blind_box: box, expected_updated_at: 'version-2' }, { handleError: false },
+ ));
+ await waitFor(() => expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe(''));
+ const beforeRename = { ...secret, updated_at: 'version-2' };
+ api.listVaultSecrets.mockResolvedValue({
+ ok: true,
+ secrets: [{ ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' }],
+ });
+ rendered.rerender(
+ <I18nextProvider i18n={i18n}>
+ <VaultSecretFieldsEditor secret={beforeRename} disabled={false} onBusyChange={vi.fn()} />
+ </I18nextProvider>,
+ );
+ api.updateVaultSecret.mockResolvedValue({ ok: true, secret: { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' } });
+ change('Default field name', 'credential');
+ fireEvent.click(screen.getByRole('button', { name: 'Rename' }));
+ await screen.findByLabelText('Value for credential');
+ expect(api.updateVaultSecret).toHaveBeenCalledWith('LOGIN', { default_field: 'credential' }, { handleError: false });
+ rendered.rerender(
+ <I18nextProvider i18n={i18n}>
+ <VaultSecretFieldsEditor secret={{ ...beforeRename }} disabled={false} onBusyChange={vi.fn()} />
+ </I18nextProvider>,
+ );
+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential');
+ api.updateVaultSecretField.mockResolvedValue({ ok: true, secret: { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-3' } });
+ change('Value for credential', 'next');
+ fireEvent.click(screen.getByRole('button', { name: 'Save credential' }));
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenLastCalledWith(
+ 'LOGIN', 'credential', { record: 'LOGIN', blind_box: box, expected_updated_at: 'version-2' }, { handleError: false },
+ ));
+ expect(sealBlindBox.mock.calls.map((call) => (call as unknown[])[2])).toEqual([
+ { purpose: 'seal', name: 'LOGIN' }, { purpose: 'seal', name: 'LOGIN.username' }, { purpose: 'seal', name: 'LOGIN' },
+ ]);
+});
+
+it('moves a typed default value when its label is renamed', async () => {
+ api.updateVaultSecret.mockResolvedValue({
+ ok: true,
+ secret: { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-1' },
+ });
+ renderEditor();
+ change('Value for password', 'typed-default');
+ change('Default field name', 'credential');
+ fireEvent.click(screen.getByRole('button', { name: 'Rename' }));
+ await waitFor(() => expect(screen.getByLabelText('Value for credential')).toBeTruthy());
+ expect((screen.getByLabelText('Value for credential') as HTMLInputElement).value).toBe('typed-default');
+});
+
+it('keeps a typed default label when saving another field', async () => {
+ api.updateVaultSecretField.mockResolvedValue({
+ ok: true,
+ secret: { ...secret, updated_at: 'version-2' },
+ });
+ renderEditor();
+ change('Default field name', 'credential');
+ change('Value for username', 'typed-extra');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ await screen.findByRole('status');
+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential');
+});
+
+it('accepts a server refetch after a legitimate quick rename back before parent acknowledgement', async () => {
+ const renamedByUser = { ...secret, default_field: 'password', fields: ['password', 'username'] };
+ const renamedBackExternally = { ...secret, default_field: 'value', fields: ['value', 'username'] };
+ api.updateVaultSecret.mockResolvedValueOnce({ ok: true, secret: renamedByUser });
+ const rendered = renderEditor();
+ change('Default field name', 'password');
+ fireEvent.click(screen.getByRole('button', { name: 'Rename' }));
+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('password'));
+
+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [renamedBackExternally] });
+ rendered.rerender(
+ <I18nextProvider i18n={i18n}>
+ <VaultSecretFieldsEditor secret={renamedBackExternally} disabled={false} onBusyChange={vi.fn()} />
+ </I18nextProvider>,
+ );
+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false }));
+ expect((screen.getAllByLabelText('Default field name').at(-1) as HTMLInputElement).value).toBe('value');
+});
+
+it('ignores an older refetch when a newer authoritative read finishes first', async () => {
+ const older = deferred<{ ok: boolean; secrets: VaultSecret[] }>();
+ const newer = deferred<{ ok: boolean; secrets: VaultSecret[] }>();
+ api.listVaultSecrets.mockReturnValueOnce(older.promise).mockReturnValueOnce(newer.promise);
+ renderEditor();
+ const newerShape = { ...secret, default_field: 'new', fields: ['new', 'username'], updated_at: 'version-3' };
+ await act(async () => {
+ eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' });
+ eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' });
+ });
+ await act(async () => { newer.resolve({ ok: true, secrets: [newerShape] }); await newer.promise; });
+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('new'));
+ await act(async () => { older.reject(new Error('older read failed')); await older.promise.catch(() => undefined); });
+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('new');
+ expect(screen.queryByLabelText('Value for old')).toBeNull();
+ expect(screen.queryByRole('alert')).toBeNull();
+});
+
+it('invalidates an older read when its own write becomes authoritative', async () => {
+ const older = deferred<{ ok: boolean; secrets: VaultSecret[] }>();
+ api.listVaultSecrets.mockReturnValueOnce(older.promise);
+ renderEditor();
+ await act(async () => {
+ eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' });
+ });
+
+ const ownWrite = { ...secret, updated_at: 'version-2' };
+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: true, secret: ownWrite });
+ change('Value for password', 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));
+ await screen.findByRole('status');
+ await act(async () => { older.resolve({ ok: true, secrets: [secret] }); await older.promise; });
+
+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: true, secret: { ...ownWrite, updated_at: 'version-3' } });
+ change('Value for username', 'next-user');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenLastCalledWith(
+ 'LOGIN', 'username', { record: 'LOGIN.username', blind_box: box, expected_updated_at: 'version-2' }, { handleError: false },
+ ));
+});
+
+it('catches up after an authoritative read lands while a write is in flight', async () => {
+ const read = deferred<{ ok: boolean; secrets: VaultSecret[] }>();
+ const write = deferred<{ ok: boolean; secret: VaultSecret }>();
+ const newerTruth = { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' };
+ api.listVaultSecrets.mockReturnValueOnce(read.promise).mockResolvedValueOnce({ ok: true, secrets: [newerTruth] });
+ api.updateVaultSecretField.mockReturnValueOnce(write.promise);
+ renderEditor();
+ await act(async () => { eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' }); });
+ change('Value for password', 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledOnce());
+ await act(async () => { read.resolve({ ok: true, secrets: [newerTruth] }); await read.promise; });
+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential'));
+ write.resolve({ ok: true, secret: { ...secret, updated_at: 'version-2' } });
+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(2));
+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential');
+});
+
+it.each(['connected', 'updated'] as const)('refetches authoritative truth on vaults.%s', async (event) => {
+ const refreshed = { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' };
+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [refreshed] });
+ renderEditor();
+ await act(async () => {
+ if (event === 'connected') eventHandlers?.onConnected?.();
+ else eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' });
+ });
+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential'));
+ expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false });
+});
+
+it('drops removed drafts and shows a localized notice', async () => {
+ api.listVaultSecrets.mockResolvedValueOnce({
+ ok: true,
+ secrets: [{ ...secret, fields: ['password'], updated_at: 'version-2' }],
+ });
+ renderEditor();
+ change('Value for username', 'draft-user');
+ await act(async () => { eventHandlers?.onVaultsUpdated?.({ scope: 'secret', secret_name: 'LOGIN' }); });
+ await waitFor(() => expect(screen.getByRole('status').textContent).toContain('username'));
+ expect(screen.queryByLabelText('Value for username')).toBeNull();
+});
+
+it.each(['constructor', 'tostring', 'valueof'])('treats %s as a normal field key', async (field) => {
+ const entry = { ...secret, fields: ['password', field] };
+ api.updateVaultSecretField.mockResolvedValue({
+ ok: true,
+ secret: { ...entry, updated_at: 'version-2' },
+ });
+ renderEditor(entry);
+ const value = screen.getByLabelText(`Value for ${field}`) as HTMLInputElement;
+ const save = screen.getByRole('button', { name: `Save ${field}` }) as HTMLButtonElement;
+ expect(value.value).toBe('');
+ expect(save.disabled).toBe(true);
+ fireEvent.change(value, { target: { value: 'typed-value' } });
+ expect(save.disabled).toBe(false);
+ fireEvent.click(save);
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledWith(
+ 'LOGIN',
+ field,
+ { record: `LOGIN.${field}`, blind_box: box, expected_updated_at: 'version-1' },
+ { handleError: false },
+ ));
+ expect(sealBlindBox).toHaveBeenCalledWith(
+ 'typed-value',
+ { public_key: 'public' },
+ { purpose: 'seal', name: `LOGIN.${field}` },
+ );
+});
+
+it.each(['version-1', 'version-2'])('adopts current labels at %s while preserving default and extra drafts', async (updated_at) => {
+ const { rerender } = renderEditor();
+ change('Value for password', 'keep-default-draft');
+ change('Value for username', 'keep-this-draft');
+ const renamed = {
+ ...secret,
+ default_field: 'credential',
+ fields: ['credential', 'username'],
+ updated_at,
+ };
+ api.listVaultSecrets.mockResolvedValue({ ok: true, secrets: [renamed] });
+ rerender(
+ <I18nextProvider i18n={i18n}>
+ <VaultSecretFieldsEditor secret={renamed} disabled={false} onBusyChange={vi.fn()} />
+ </I18nextProvider>,
+ );
+ await waitFor(() => expect((screen.getByLabelText('Default field name') as HTMLInputElement).value).toBe('credential'));
+ expect((screen.getByLabelText('Value for credential') as HTMLInputElement).value).toBe('keep-default-draft');
+ expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe('keep-this-draft');
+});
+
+it('warns and disables field mutations when field metadata is corrupt', () => {
+ renderEditor({ ...secret, fields_state: 'corrupt' });
+ expect(screen.getByRole('alert').textContent).toBe(en.errors.fields_corrupt);
+ expect((screen.getByLabelText('Default field name') as HTMLInputElement).disabled).toBe(true);
+ expect((screen.getByLabelText('Value for password') as HTMLInputElement).disabled).toBe(true);
+ expect((screen.getByRole('button', { name: 'Rename' }) as HTMLButtonElement).disabled).toBe(true);
+ expect((screen.getByRole('button', { name: 'Save password' }) as HTMLButtonElement).disabled).toBe(true);
+ expect((screen.getByRole('button', { name: 'Remove username' }) as HTMLButtonElement).disabled).toBe(true);
+ expect((screen.getByRole('button', { name: 'Add field' }) as HTMLButtonElement).disabled).toBe(true);
+});
+
+it('adopts a same-version corruption state from refreshed metadata', async () => {
+ api.listVaultSecrets.mockResolvedValueOnce({
+ ok: true,
+ secrets: [{ ...secret, fields_state: 'corrupt' }],
+ });
+ const { rerender } = renderEditor();
+ rerender(
+ <I18nextProvider i18n={i18n}>
+ <VaultSecretFieldsEditor secret={{ ...secret, fields_state: 'corrupt' }} disabled={false} onBusyChange={vi.fn()} />
+ </I18nextProvider>,
+ );
+ await waitFor(() => expect(screen.getByRole('alert').textContent).toBe(en.errors.fields_corrupt));
+ expect((screen.getByRole('button', { name: 'Save password' }) as HTMLButtonElement).disabled).toBe(true);
+});
+
+it('requires a unique populated extra field, saves it under its record name, and confirms removal', async () => {
+ renderEditor();
+ fireEvent.click(screen.getByRole('button', { name: 'Add field' }));
+ change('New field name', 'username');
+ change('New field value', 'seed');
+ expect((screen.getByRole('button', { name: 'Save field' }) as HTMLButtonElement).disabled).toBe(true);
+ change('New field name', 'totp');
+ api.updateVaultSecretField.mockResolvedValue({ ok: true, secret: { ...secret, fields: ['password', 'username', 'totp'], updated_at: 'version-2' } });
+ fireEvent.click(screen.getByRole('button', { name: 'Save field' }));
+ await screen.findByLabelText('Value for totp');
+ expect(sealBlindBox).toHaveBeenCalledWith('seed', { public_key: 'public' }, { purpose: 'seal', name: 'LOGIN.totp' });
+ expect(screen.queryByRole('button', { name: 'Remove password' })).toBeNull();
+ fireEvent.click(screen.getByRole('button', { name: 'Remove totp' }));
+ expect(api.deleteVaultSecretField).not.toHaveBeenCalled();
+ api.deleteVaultSecretField.mockResolvedValue({ ok: true, secret: { ...secret, updated_at: 'version-3' } });
+ fireEvent.click(screen.getByRole('button', { name: en.vaults.delete }));
+ await waitFor(() => expect(api.deleteVaultSecretField).toHaveBeenCalledWith('LOGIN', 'totp', { expected_updated_at: 'version-2' }));
+ await waitFor(() => expect(screen.queryByLabelText('Value for totp')).toBeNull());
+});
+
+it('refreshes a stale delete version without removing the newer field or retrying', async () => {
+ api.deleteVaultSecretField.mockRejectedValueOnce(new ApiError('stale delete', 409, 'secret_conflict'));
+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [{ ...secret, updated_at: 'version-8' }] });
+ renderEditor();
+ fireEvent.click(screen.getByRole('button', { name: 'Remove username' }));
+ fireEvent.click(screen.getByRole('button', { name: en.vaults.delete }));
+ expect((await screen.findByRole('alert')).textContent).toBe(en.vaults.fields.secretConflict);
+ expect(api.deleteVaultSecretField).toHaveBeenCalledOnce();
+ expect(screen.getByLabelText('Value for username')).toBeTruthy();
+ api.deleteVaultSecretField.mockResolvedValueOnce({ ok: true, secret: { ...secret, fields: ['password'], updated_at: 'version-9' } });
+ fireEvent.click(screen.getByRole('button', { name: 'Remove username' }));
+ fireEvent.click(screen.getByRole('button', { name: en.vaults.delete }));
+ await waitFor(() => expect(screen.queryByLabelText('Value for username')).toBeNull());
+ expect(api.deleteVaultSecretField.mock.calls).toEqual([
+ ['LOGIN', 'username', { expected_updated_at: 'version-1' }],
+ ['LOGIN', 'username', { expected_updated_at: 'version-8' }],
+ ]);
+});
+
+it('renders a Chinese field validation error from the stable code', async () => {
+ await i18n.changeLanguage('zh');
+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'field_not_found', message: 'field not found on LOGIN' });
+ renderEditor();
+ change(i18n.t('vaults.fields.value', { field: 'username' }), 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: i18n.t('vaults.fields.saveNamed', { field: 'username' }) }));
+ expect((await screen.findByRole('alert')).textContent).toBe(zh.errors.field_not_found);
+});
+
+it.each(['response', 'exception'])('refreshes a conflicting version without retrying, then permits a new save (%s)', async (failure) => {
+ const fresh = { ...secret, updated_at: 'version-9' };
+ if (failure === 'exception') {
+ api.updateVaultSecretField.mockRejectedValueOnce(new ApiError('stale version', 409, 'secret_conflict'));
+ } else {
+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'secret_conflict' });
+ }
+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [fresh] });
+ api.updateVaultSecretField.mockResolvedValue({ ok: true, secret: { ...fresh, updated_at: 'version-10' } });
+ renderEditor();
+ change('Value for username', 'new-user');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ expect((await screen.findByRole('alert')).textContent).toBe(en.vaults.fields.secretConflict);
+ expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false });
+ expect(api.updateVaultSecretField).toHaveBeenCalledOnce();
+ expect(screen.queryByRole('status')).toBeNull();
+ expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe('new-user');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ await screen.findByRole('status');
+ expect(api.updateVaultSecretField).toHaveBeenCalledTimes(2);
+ expect(api.updateVaultSecretField.mock.calls[1][2].expected_updated_at).toBe('version-9');
+});
+
+it('seals a protected replacement with its field record and drops its entered value', async () => {
+ const envelope = { ciphertext: 'ciphertext', nonce: 'nonce', wrap_meta: '{}' };
+ vault.sealValue.mockImplementation(async (_name, _kind, value) => { value.clear(); return { envelope }; });
+ renderEditor({ ...secret, protection: 'protected' });
+ change('Value for username', '私密用户');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledWith(
+ 'LOGIN', 'username', { record: 'LOGIN.username', sealed: envelope, expected_updated_at: 'version-1' }, { handleError: false },
+ ));
+ expect(vault.sealValue.mock.calls[0].slice(0, 2)).toEqual(['LOGIN.username', 'static']);
+ expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe('');
+ expect(sealBlindBox).not.toHaveBeenCalled();
+});
+
+it('re-reads metadata and re-seals exactly once after a record mismatch', async () => {
+ const renamed = { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' };
+ api.updateVaultSecretField
+ .mockResolvedValueOnce({ ok: false, code: 'record_mismatch', message: 'stale record' })
+ .mockResolvedValueOnce({ ok: true, secret: { ...renamed, updated_at: 'version-3' } });
+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [renamed] });
+ renderEditor();
+ change('Value for password', 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledTimes(2));
+ expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false });
+ expect(api.updateVaultSecretField.mock.calls).toEqual([
+ ['LOGIN', 'password', { record: 'LOGIN', blind_box: box, expected_updated_at: 'version-1' }, { handleError: false }],
+ ['LOGIN', 'credential', { record: 'LOGIN', blind_box: box, expected_updated_at: 'version-2' }, { handleError: false }],
+ ]);
+ expect(sealBlindBox).toHaveBeenCalledTimes(2);
+ expect((screen.getByLabelText('Value for credential') as HTMLInputElement).value).toBe('');
+ expect(screen.queryByRole('alert')).toBeNull();
+});
+
+it('surfaces an extra-field record conflict without retrying under a changed default label', async () => {
+ const changed = { ...secret, default_field: 'username', fields: ['username'], updated_at: 'version-2' };
+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'record_mismatch', message: 'stale record' });
+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [changed] });
+ renderEditor();
+ change('Value for username', 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ await waitFor(() => expect(screen.getByRole('alert')).toBeTruthy());
+ expect(api.updateVaultSecretField).toHaveBeenCalledOnce();
+ expect(sealBlindBox).toHaveBeenCalledOnce();
+});
+
+it('retries a record mismatch with the superseded read entry', async () => {
+ const retryRead = deferred<{ ok: boolean; secrets: VaultSecret[] }>();
+ const propRead = deferred<{ ok: boolean; secrets: VaultSecret[] }>();
+ const renamed = { ...secret, default_field: 'credential', fields: ['credential', 'username'], updated_at: 'version-2' };
+ api.updateVaultSecretField
+ .mockResolvedValueOnce({ ok: false, code: 'record_mismatch', message: 'stale record' })
+ .mockResolvedValueOnce({ ok: true, secret: { ...renamed, updated_at: 'version-3' } });
+ api.listVaultSecrets.mockReturnValueOnce(retryRead.promise).mockReturnValueOnce(propRead.promise);
+ const rendered = renderEditor();
+ change('Value for password', 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: 'Save password' }));
+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(1));
+ rendered.rerender(
+ <I18nextProvider i18n={i18n}>
+ <VaultSecretFieldsEditor secret={{ ...secret, updated_at: 'version-2' }} disabled={false} onBusyChange={vi.fn()} />
+ </I18nextProvider>,
+ );
+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(2));
+ await act(async () => {
+ propRead.resolve({ ok: true, secrets: [renamed] });
+ retryRead.resolve({ ok: true, secrets: [renamed] });
+ await Promise.all([propRead.promise, retryRead.promise]);
+ });
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledTimes(2));
+ expect(api.updateVaultSecretField.mock.calls[1][2].expected_updated_at).toBe('version-2');
+});
+
+it('keeps a secret conflict after its refresh is superseded', async () => {
+ const conflictRead = deferred<{ ok: boolean; secrets: VaultSecret[] }>();
+ const propRead = deferred<{ ok: boolean; secrets: VaultSecret[] }>();
+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'secret_conflict' });
+ api.listVaultSecrets.mockReturnValueOnce(conflictRead.promise).mockReturnValueOnce(propRead.promise);
+ const rendered = renderEditor();
+ change('Value for username', 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(1));
+ rendered.rerender(
+ <I18nextProvider i18n={i18n}>
+ <VaultSecretFieldsEditor secret={{ ...secret, updated_at: 'version-2' }} disabled={false} onBusyChange={vi.fn()} />
+ </I18nextProvider>,
+ );
+ await waitFor(() => expect(api.listVaultSecrets).toHaveBeenCalledTimes(2));
+ await act(async () => {
+ propRead.resolve({ ok: true, secrets: [secret] });
+ conflictRead.resolve({ ok: true, secrets: [secret] });
+ await Promise.all([propRead.promise, conflictRead.promise]);
+ });
+ expect((await screen.findByRole('alert')).textContent).toBe(en.vaults.fields.secretConflict);
+});
+
+it('shows a missing-secret error when a conflict refresh finds no secret', async () => {
+ api.updateVaultSecretField.mockResolvedValueOnce({ ok: false, code: 'secret_conflict' });
+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [] });
+ renderEditor();
+ change('Value for username', 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ expect((await screen.findByRole('alert')).textContent).toBe(en.errors.secret_not_found);
+});
+
+it('does not report a dropped draft when its field is cleared before own removal', async () => {
+ api.deleteVaultSecretField.mockResolvedValueOnce({ ok: true, secret: { ...secret, fields: ['password'], updated_at: 'version-2' } });
+ renderEditor();
+ change('Value for username', 'temporary');
+ change('Value for username', '');
+ fireEvent.click(screen.getByRole('button', { name: 'Remove username' }));
+ fireEvent.click(screen.getByRole('button', { name: en.vaults.delete }));
+ await waitFor(() => expect(screen.queryByLabelText('Value for username')).toBeNull());
+ expect(screen.queryByText(en.vaults.fields.draftsDropped.replace('{{fields}}', 'username'))).toBeNull();
+});
+
+it('retries once when the API client throws ApiError for record_mismatch', async () => {
+ api.updateVaultSecretField
+ .mockRejectedValueOnce(new ApiError('stale record', 409, 'record_mismatch'))
+ .mockResolvedValueOnce({ ok: true, secret: { ...secret, updated_at: 'version-2' } });
+ api.listVaultSecrets.mockResolvedValueOnce({ ok: true, secrets: [secret] });
+ renderEditor();
+ change('Value for username', 'replacement');
+ fireEvent.click(screen.getByRole('button', { name: 'Save username' }));
+ await waitFor(() => expect(api.updateVaultSecretField).toHaveBeenCalledTimes(2));
+ expect(api.listVaultSecrets).toHaveBeenCalledWith({ cache: false });
+ expect(api.updateVaultSecretField.mock.calls[1][2]).toMatchObject({ record: 'LOGIN.username', expected_updated_at: 'version-1' });
+});
diff --git a/ui/src/components/ui/vault-secret-fields-editor.tsx b/ui/src/components/ui/vault-secret-fields-editor.tsx
new file mode 100644
index 000000000..39c3e772c
--- /dev/null
+++ b/ui/src/components/ui/vault-secret-fields-editor.tsx
@@ -0,0 +1,388 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Loader2, Plus, X } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import { useApi, type VaultFieldValuePayload, type VaultSecret } from '@/context/ApiContext';
+import { sealBlindBox, standardCreateBlindBoxContext } from '@/lib/vaultCrypto';
+import { vaultErrorMessage } from '@/lib/vaultErrors';
+import { useProtectedVault } from '@/lib/useProtectedVault';
+import { openVaultsInBrowser } from '@/lib/vaultBrowserHandoff';
+import { MAX_VAULT_FIELDS, VAULT_FIELD_PATTERN, vaultDefaultField, vaultFieldNames, vaultRecordName } from '@/lib/vaultFields';
+import { Badge } from './badge';
+import { Button } from './button';
+import { ConfirmDialog } from './confirm-dialog';
+import { Input } from './input';
+import { VaultProtectedUnlock } from './vault-protected-unlock';
+
+type DraftReconciliation = {
+ drafts: Map<string, string>;
+ removed: string[];
+};
+
+function reconcileDrafts(previous: VaultSecret, next: VaultSecret, drafts: ReadonlyMap<string, string>): DraftReconciliation {
+ const reconciled = new Map(drafts);
+ const previousDefault = vaultDefaultField(previous);
+ const nextDefault = vaultDefaultField(next);
+ if (previousDefault !== nextDefault && reconciled.has(previousDefault)) {
+ reconciled.set(nextDefault, reconciled.get(previousDefault) ?? '');
+ reconciled.delete(previousDefault);
+ }
+
+ const names = new Set(vaultFieldNames(next));
+ const removed: string[] = [];
+ for (const name of reconciled.keys()) {
+ if (!names.has(name)) {
+ const value = reconciled.get(name);
+ reconciled.delete(name);
+ if (value) removed.push(name);
+ }
+ }
+ return { drafts: reconciled, removed };
+}
+
+/** Each field mutation returns the next metadata version for the following browser envelope. */
+export function VaultSecretFieldsEditor({
+ secret, disabled, onBusyChange,
+}: {
+ secret: VaultSecret;
+ disabled: boolean;
+ onBusyChange: (busy: boolean) => void;
+}) {
+ const { t } = useTranslation();
+ const api = useApi();
+ const vault = useProtectedVault();
+ const { refresh } = vault;
+ const [current, setCurrent] = useState(secret);
+ const currentRef = useRef(secret);
+ const truthRevisionRef = useRef(0);
+ const initialSecretRef = useRef(secret);
+ const [drafts, setDraftsState] = useState<Map<string, string>>(() => new Map());
+ const draftsRef = useRef<Map<string, string>>(new Map());
+ const [defaultLabel, setDefaultLabel] = useState(vaultDefaultField(secret));
+ const defaultLabelDirtyRef = useRef(false);
+ const [newField, setNewField] = useState<string | null>(null);
+ const [newValue, setNewValue] = useState('');
+ const [busy, setBusy] = useState(false);
+ const [error, setError] = useState<string | null>(null);
+ const [saved, setSaved] = useState(false);
+ const [removeField, setRemoveField] = useState<string | null>(null);
+ const [draftNotice, setDraftNotice] = useState<string | null>(null);
+ const fields = vaultFieldNames(current);
+ const defaultField = vaultDefaultField(current);
+ const isProtected = current.protection === 'protected';
+ const locked = disabled || busy;
+ const fieldsCorrupt = current.fields_state === 'corrupt';
+ const fieldMutationLocked = locked || fieldsCorrupt;
+ const canWriteValue = !isProtected || vault.status === 'unlocked';
+
+ useEffect(() => {
+ if (isProtected) void refresh();
+ }, [isProtected, refresh]);
+
+ const hasErrorCode = (result: unknown, code: string): boolean =>
+ typeof result === 'object' && result !== null && 'code' in result && result.code === code;
+ const conflict = () => new Error(t('vaults.fields.recordConflict'));
+ const updateDrafts = useCallback((next: Map<string, string>) => {
+ draftsRef.current = next;
+ setDraftsState(next);
+ }, []);
+ const applyTruth = useCallback((next: VaultSecret, ownRename = false) => {
+ const previous = currentRef.current;
+ currentRef.current = next;
+ truthRevisionRef.current += 1;
+ setCurrent(next);
+ const nextDefault = vaultDefaultField(next);
+ if (ownRename || !defaultLabelDirtyRef.current) {
+ setDefaultLabel(nextDefault);
+ }
+ if (ownRename) defaultLabelDirtyRef.current = false;
+ const reconciled = reconcileDrafts(previous, next, draftsRef.current);
+ updateDrafts(reconciled.drafts);
+ if (reconciled.removed.length > 0) {
+ setDraftNotice(t('vaults.fields.draftsDropped', { fields: reconciled.removed.join(', ') }));
+ } else {
+ setDraftNotice(null);
+ }
+ }, [t, updateDrafts]);
+
+ const refetchSequenceRef = useRef(0);
+ const invalidatePendingRefetches = useCallback(() => {
+ refetchSequenceRef.current += 1;
+ }, []);
+ type RefetchResult = {
+ status: 'applied' | 'superseded' | 'missing';
+ entry: VaultSecret | null;
+ };
+ const refetch = useCallback(async (): Promise<RefetchResult> => {
+ const sequence = ++refetchSequenceRef.current;
+ try {
+ const result = await api.listVaultSecrets({ cache: false });
+ const next = result.secrets.find((entry) => entry.name === currentRef.current.name) ?? null;
+ if (sequence !== refetchSequenceRef.current) return { status: 'superseded', entry: next };
+ if (!next) return { status: 'missing', entry: null };
+ applyTruth(next);
+ return { status: 'applied', entry: next };
+ } catch (refetchError) {
+ if (sequence !== refetchSequenceRef.current) return { status: 'superseded', entry: null };
+ throw refetchError;
+ }
+ }, [api, applyTruth]);
+
+ const handleRefetchResult = useCallback((result: RefetchResult) => {
+ if (result.status === 'missing') setError(t('errors.secret_not_found'));
+ }, [t]);
+
+ const surfaceRefetchError = useCallback((refetchError: unknown) => {
+ setError(vaultErrorMessage(t, refetchError, t('vaults.dialog.errors.updateFailed')));
+ }, [t]);
+
+ useEffect(() => {
+ const refreshFromEvent = () => {
+ void refetch().then(handleRefetchResult).catch(surfaceRefetchError);
+ };
+ const disconnect = api.connectWorkbenchEvents({
+ onConnected: refreshFromEvent,
+ onVaultsUpdated: (data) => {
+ if (!data.secret_name || data.secret_name === currentRef.current.name) refreshFromEvent();
+ },
+ });
+ return () => disconnect?.();
+ }, [api, refetch, handleRefetchResult, surfaceRefetchError]);
+
+ useEffect(() => {
+ if (secret === initialSecretRef.current) return;
+ initialSecretRef.current = secret;
+ // Parent updates are only a signal to read server truth; the mounted editor
+ // never adopts the prop directly.
+ if (secret.name !== currentRef.current.name) return;
+ void refetch().then(handleRefetchResult).catch(surfaceRefetchError);
+ }, [secret, refetch, handleRefetchResult, surfaceRefetchError]);
+
+ useEffect(() => () => {
+ refetchSequenceRef.current += 1;
+ }, []);
+
+ const mutate = async (
+ operation: () => Promise<{ ok: boolean; secret?: VaultSecret; message?: string; code?: string }>,
+ renamed = false,
+ operationRefetched: () => boolean = () => false,
+ ) => {
+ if (locked) return;
+ const writeStartTruthRevision = truthRevisionRef.current;
+ const writeStartSequence = refetchSequenceRef.current;
+ setBusy(true);
+ onBusyChange(true);
+ setError(null);
+ setSaved(false);
+ setDraftNotice(null);
+ try {
+ const result = await operation();
+ if (!result.ok || !result.secret) {
+ throw Object.assign(new Error(vaultErrorMessage(t, result, t('vaults.dialog.errors.updateFailed'))), { code: result.code });
+ }
+ const next = result.secret;
+ const needsCatchup = (
+ refetchSequenceRef.current !== writeStartSequence
+ || truthRevisionRef.current !== writeStartTruthRevision
+ ) && !operationRefetched();
+ invalidatePendingRefetches();
+ applyTruth(next, renamed);
+ setSaved(true);
+ if (needsCatchup) {
+ try {
+ const refreshed = await refetch();
+ if (refreshed.status === 'missing') {
+ setError(t('errors.secret_not_found'));
+ }
+ } catch (catchupError) {
+ surfaceRefetchError(catchupError);
+ }
+ }
+ } catch (err) {
+ if (hasErrorCode(err, 'secret_conflict')) {
+ try {
+ const refreshed = await refetch();
+ if (refreshed.status === 'missing') {
+ setError(t('errors.secret_not_found'));
+ } else {
+ setError(t('vaults.fields.secretConflict'));
+ }
+ } catch (refreshError) {
+ setError(vaultErrorMessage(t, refreshError, t('vaults.dialog.errors.updateFailed')));
+ }
+ } else {
+ setError(vaultErrorMessage(t, err, t('vaults.dialog.errors.updateFailed')));
+ }
+ } finally {
+ setBusy(false);
+ onBusyChange(false);
+ }
+ };
+
+ const saveValue = (field: string, value: string, adding = false) => {
+ // Keep this one local copy only until the write settles. Protected sealing clears the
+ // persistent input immediately through `clear`, while this copy permits exactly one
+ // re-seal if the server reports that its record mapping changed.
+ let capturedValue = value;
+ const clear = (targetField = field) => {
+ if (adding) {
+ setNewValue('');
+ return;
+ }
+ const next = new Map(draftsRef.current);
+ next.set(targetField, '');
+ updateDrafts(next);
+ };
+ const sealAndWrite = async (secret: VaultSecret, targetField: string, wasDefault: boolean) => {
+ const latestDefault = vaultDefaultField(secret);
+ if (!wasDefault && latestDefault === targetField) throw conflict();
+ const exists = vaultFieldNames(secret).includes(targetField);
+ if (adding ? exists : !exists) throw conflict();
+ const record = vaultRecordName(secret.name, targetField, latestDefault);
+ let cryptoFields: Omit<VaultFieldValuePayload, 'record' | 'expected_updated_at'>;
+ if (isProtected) {
+ const valueRef = { current: capturedValue };
+ const sealed = await vault.sealValue(record, 'static', { valueRef, clear });
+ cryptoFields = { sealed: sealed.envelope };
+ } else {
+ cryptoFields = {
+ blind_box: await sealBlindBox(capturedValue, await api.getVaultPubkey(), standardCreateBlindBoxContext(record)),
+ };
+ }
+ try {
+ return await api.updateVaultSecretField(secret.name, targetField, {
+ record,
+ ...cryptoFields,
+ expected_updated_at: secret.updated_at,
+ }, { handleError: false });
+ } catch (error) {
+ if (hasErrorCode(error, 'record_mismatch')) return { ok: false, code: 'record_mismatch' };
+ if (hasErrorCode(error, 'secret_conflict')) return { ok: false, code: 'secret_conflict' };
+ throw error;
+ }
+ };
+ let refetchedForRetry = false;
+ void mutate(async () => {
+ try {
+ const wasDefault = field === defaultField;
+ let savedField = field;
+ let result = await sealAndWrite(current, field, wasDefault);
+ if (hasErrorCode(result, 'record_mismatch')) {
+ refetchedForRetry = true;
+ const refreshed = await refetch();
+ if (!refreshed.entry) {
+ setError(t('errors.secret_not_found'));
+ return { ok: false, code: 'secret_not_found' };
+ }
+ savedField = wasDefault ? vaultDefaultField(refreshed.entry) : field;
+ result = await sealAndWrite(refreshed.entry, savedField, wasDefault);
+ if (hasErrorCode(result, 'record_mismatch')) throw conflict();
+ }
+ if (result.ok && result.secret) {
+ clear(savedField);
+ if (adding) setNewField(null);
+ }
+ return result;
+ } finally {
+ capturedValue = '';
+ }
+ }, false, () => refetchedForRetry);
+ };
+
+ return (
+ <div className="flex flex-col gap-3" onKeyDown={(event) => {
+ // These inputs save through their field buttons, not the enclosing metadata form.
+ if (event.key === 'Enter' && event.target instanceof HTMLInputElement) event.preventDefault();
+ }}>
+ <span className="text-[13px] font-medium">{t('vaults.fields.title')}</span>
+ <p className="text-[11px] text-muted-foreground">{t('vaults.fields.editHelp')}</p>
+ {draftNotice && (
+ <p role="status" className="text-xs text-muted-foreground">{draftNotice}</p>
+ )}
+ {fieldsCorrupt && (
+ <p role="alert" className="text-xs text-destructive-ink">{t('errors.fields_corrupt')}</p>
+ )}
+ {fields.map((field) => (
+ <div key={field} className="flex flex-col gap-2 rounded-lg border border-border p-3">
+ <div className="flex items-center gap-2">
+ {field === defaultField ? (
+ <>
+ <Input value={defaultLabel} disabled={fieldMutationLocked}
+ aria-label={t('vaults.fields.defaultName')}
+ onChange={(event) => {
+ defaultLabelDirtyRef.current = true;
+ setDefaultLabel(event.target.value);
+ }}
+ className="min-w-0 font-mono" />
+ <Badge variant="secondary">{t('vaults.fields.default')}</Badge>
+ <Button type="button" size="sm" variant="ghost"
+ disabled={fieldMutationLocked || defaultLabel === defaultField || !VAULT_FIELD_PATTERN.test(defaultLabel) || fields.includes(defaultLabel)}
+ onClick={() => void mutate(
+ () => api.updateVaultSecret(current.name, { default_field: defaultLabel }, { handleError: false }),
+ true,
+ )}>
+ {t('vaults.fields.rename')}
+ </Button>
+ </>
+ ) : (
+ <>
+ <span className="min-w-0 flex-1 break-all font-mono text-xs">{field}</span>
+ <Button type="button" size="icon" variant="ghost" disabled={fieldMutationLocked}
+ aria-label={t('vaults.fields.remove', { field })} onClick={() => setRemoveField(field)}>
+ <X className="size-4" />
+ </Button>
+ </>
+ )}
+ </div>
+ <div className="flex items-center gap-2">
+ <Input type="password" value={drafts.get(field) ?? ''} autoComplete="off" disabled={fieldMutationLocked}
+ aria-label={t('vaults.fields.value', { field })}
+ placeholder={t('vaults.fields.replacePlaceholder')}
+ onChange={(event) => {
+ const next = new Map(draftsRef.current);
+ next.set(field, event.target.value);
+ updateDrafts(next);
+ }} />
+ <Button type="button" variant="secondary" size="sm"
+ aria-label={t('vaults.fields.saveNamed', { field })}
+ disabled={fieldMutationLocked || !canWriteValue || !drafts.get(field)}
+ onClick={() => saveValue(field, drafts.get(field) ?? '')}>{t('vaults.fields.save')}</Button>
+ </div>
+ </div>
+ ))}
+ {newField !== null ? (
+ <div className="flex flex-col gap-2 rounded-lg border border-border p-3">
+ <Input value={newField} disabled={fieldMutationLocked} aria-label={t('vaults.fields.newName')}
+ placeholder={t('vaults.fields.namePlaceholder')} onChange={(event) => setNewField(event.target.value)} />
+ <Input type="password" value={newValue} autoComplete="off" disabled={fieldMutationLocked}
+ aria-label={t('vaults.fields.newValue')} placeholder={t('vaults.dialog.valuePlaceholder')}
+ onChange={(event) => setNewValue(event.target.value)} />
+ <div className="flex justify-end gap-2">
+ <Button type="button" variant="ghost" size="sm" disabled={locked}
+ onClick={() => { setNewField(null); setNewValue(''); }}>{t('vaults.dialog.cancel')}</Button>
+ <Button type="button" size="sm"
+ disabled={fieldMutationLocked || !canWriteValue || !newValue || !VAULT_FIELD_PATTERN.test(newField) || fields.includes(newField)}
+ onClick={() => saveValue(newField, newValue, true)}>{t('vaults.fields.save')}</Button>
+ </div>
+ <span className="text-[11px] text-muted-foreground">{t('vaults.fields.namesHelp')}</span>
+ </div>
+ ) : (
+ <Button type="button" variant="ghost" size="sm" className="self-start" disabled={fieldMutationLocked || fields.length >= MAX_VAULT_FIELDS}
+ onClick={() => setNewField('')}><Plus className="size-3.5" />{t('vaults.fields.add')}</Button>
+ )}
+ {isProtected && <VaultProtectedUnlock vault={vault} secretName={current.name}
+ onContinueInBrowser={() => openVaultsInBrowser({ kind: 'edit', secretName: current.name })} />}
+ {busy && <Loader2 className="size-4 animate-spin text-muted" />}
+ {saved && <p role="status" className="text-xs text-mint-ink">{t('vaults.fields.saved')}</p>}
+ {error && <p role="alert" className="text-xs text-destructive-ink">{error}</p>}
+ <ConfirmDialog open={removeField !== null} onOpenChange={(open) => { if (!open) setRemoveField(null); }}
+ title={t('vaults.fields.remove', { field: removeField })}
+ description={t('vaults.fields.removeConfirm')}
+ confirmLabel={t('vaults.delete')} cancelLabel={t('vaults.dialog.cancel')} destructive
+ onConfirm={async () => {
+ if (!removeField || fieldsCorrupt) return;
+ await mutate(() => api.deleteVaultSecretField(current.name, removeField, { expected_updated_at: current.updated_at }));
+ setRemoveField(null);
+ }} />
+ </div>
+ );
+}
diff --git a/ui/src/components/ui/vault-secret-form.test.tsx b/ui/src/components/ui/vault-secret-form.test.tsx
index 188e7ee5e..e20494d35 100644
--- a/ui/src/components/ui/vault-secret-form.test.tsx
+++ b/ui/src/components/ui/vault-secret-form.test.tsx
@@ -1,22 +1,175 @@
/* @vitest-environment jsdom */
-import { cleanup, render, waitFor } from '@testing-library/react';
-import { afterEach, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { createInstance } from 'i18next';
+import { I18nextProvider, initReactI18next } from 'react-i18next';
+import type { ReactElement } from 'react';
+import en from '@/i18n/en.json';
+import type { VaultSecret } from '@/context/ApiContext';
import { VaultSecretForm } from './vault-secret-form';
const api = vi.hoisted(() => ({
- listDependencies: vi.fn(async () => ({ ok: true, deps: [] })),
+ listDependencies: vi.fn(),
listVaultSecrets: vi.fn(async () => ({ secrets: [] })),
listSkills: vi.fn(async () => ({ skills: [] })),
createVaultSecret: vi.fn(),
+ getVaultPubkey: vi.fn(async () => ({ public_key: 'public', fingerprint: 'fingerprint' })),
+ connectWorkbenchEvents: vi.fn(() => vi.fn()),
}));
-vi.mock('@/context/ApiContext', () => ({ useApi: () => api }));
-vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
-afterEach(cleanup);
+const envelope = vi.hoisted(() => ({ ciphertext: 'ciphertext', nonce: 'nonce', wrap_meta: '{}' }));
+const blindBox = vi.hoisted(() => ({ scheme: 'test', enc: 'enc', ct: 'ciphertext' }));
+const sealBlindBox = vi.hoisted(() => vi.fn(async () => blindBox));
+const vault = vi.hoisted(() => ({
+ status: 'unlocked', refresh: vi.fn(), afterCreated: vi.fn(),
+ sealValue: vi.fn(),
+}));
+vi.mock('@/context/ApiContext', async (original) => ({
+ ...await original<typeof import('@/context/ApiContext')>(), useApi: () => api,
+}));
+vi.mock('@/lib/useProtectedVault', () => ({ useProtectedVault: () => vault }));
+vi.mock('./vault-protected-unlock', () => ({ VaultProtectedUnlock: () => null }));
+vi.mock('@/lib/vaultCrypto', async (original) => ({
+ ...await original<typeof import('@/lib/vaultCrypto')>(), sealBlindBox,
+}));
+const i18n = createInstance();
+void i18n.use(initReactI18next).init({
+ lng: 'en', fallbackLng: 'en', resources: { en: { translation: en } }, interpolation: { escapeValue: false },
+});
+const form = (element: ReactElement) => <I18nextProvider i18n={i18n}>{element}</I18nextProvider>;
+const change = (label: string, value: string) => fireEvent.change(screen.getByLabelText(label), { target: { value } });
+beforeEach(() => {
+ api.listDependencies.mockResolvedValue({ ok: true, deps: [{ id: 'avault', status: 'ready', version: '0.1.6' }] });
+ api.createVaultSecret.mockResolvedValue({ ok: true });
+ vault.sealValue.mockImplementation(async (_name, _kind, value) => {
+ value.clear();
+ return { envelope, establishingVmk: true, authzFactorRegistration: { challenge_id: 'setup' } };
+ });
+});
+afterEach(() => { cleanup(); vi.clearAllMocks(); });
it('checks only avault when the secret form opens, without creating a secret', async () => {
- render(<VaultSecretForm onCancel={vi.fn()} onCreated={vi.fn()} />);
+ render(form(<VaultSecretForm onCancel={vi.fn()} onCreated={vi.fn()} />));
await waitFor(() => expect(api.listDependencies).toHaveBeenCalledWith({ ids: ['avault'] }));
expect(api.listDependencies).toHaveBeenCalledTimes(1);
expect(api.createVaultSecret).not.toHaveBeenCalled();
});
+
+// The form owns row/default selection and wire payload assembly. Existing crypto tests do not
+// catch dropping a row, allowing a blank value, or sealing the default under NAME.password.
+it.each(['standard', 'protected'] as const)('creates a complete %s login with canonical record names and no plaintext payload', async (protection) => {
+ const onCreated = vi.fn();
+ render(form(<VaultSecretForm fixedName="GITHUB_LOGIN" defaultProtection={protection} onCancel={vi.fn()} onCreated={onCreated} />));
+ fireEvent.click(screen.getByRole('button', { name: 'Login template' }));
+ expect(screen.queryByRole('radio', { name: 'File' })).toBeNull();
+ const submit = screen.getByRole('button', { name: 'Save & let the agent continue' }) as HTMLButtonElement;
+ change('Value for username', '张三');
+ change('Value for password', '密碼');
+ expect(submit.disabled).toBe(true);
+ change('Value for totp', 'seed');
+ await waitFor(() => expect(submit.disabled).toBe(false));
+ fireEvent.click(submit);
+ await waitFor(() => expect(onCreated).toHaveBeenCalledWith('GITHUB_LOGIN', 'created'));
+ const payload = api.createVaultSecret.mock.calls[0][0];
+ expect(payload.default_field).toBe('password');
+ expect(payload.fields.map((field: { name: string }) => field.name)).toEqual(['username', 'totp']);
+ expect(JSON.stringify(payload)).not.toMatch(/张三|密碼|seed/);
+ if (protection === 'standard') {
+ expect(sealBlindBox.mock.calls.map((call) => (call as unknown[])[2])).toEqual([
+ { purpose: 'seal', name: 'GITHUB_LOGIN.username' },
+ { purpose: 'seal', name: 'GITHUB_LOGIN' },
+ { purpose: 'seal', name: 'GITHUB_LOGIN.totp' },
+ ]);
+ expect(payload.blind_box).toEqual(blindBox);
+ expect(payload.fields).toEqual([
+ { name: 'username', record: 'GITHUB_LOGIN.username', blind_box: blindBox },
+ { name: 'totp', record: 'GITHUB_LOGIN.totp', blind_box: blindBox },
+ ]);
+ } else {
+ expect(vault.sealValue.mock.calls.map((call) => call[0])).toEqual(['GITHUB_LOGIN.username', 'GITHUB_LOGIN', 'GITHUB_LOGIN.totp']);
+ expect(payload.sealed).toEqual(envelope);
+ expect(payload.establishing_vmk).toBe(true);
+ expect(payload.authz_factor_registration).toEqual({ challenge_id: 'setup' });
+ expect(payload.fields).toEqual([
+ { name: 'username', record: 'GITHUB_LOGIN.username', sealed: envelope },
+ { name: 'totp', record: 'GITHUB_LOGIN.totp', sealed: envelope },
+ ]);
+ expect(vault.afterCreated).toHaveBeenCalledOnce();
+ }
+});
+
+it('keeps the legacy single-value create payload until fields are added', async () => {
+ render(form(<VaultSecretForm fixedName="TOKEN" onCancel={vi.fn()} onCreated={vi.fn()} />));
+ fireEvent.change(screen.getByPlaceholderText(en.vaults.dialog.valuePlaceholder), { target: { value: 'token' } });
+ const submit = screen.getByRole('button', { name: 'Save & let the agent continue' }) as HTMLButtonElement;
+ await waitFor(() => expect(submit.disabled).toBe(false));
+ fireEvent.click(submit);
+ await waitFor(() => expect(api.createVaultSecret).toHaveBeenCalledOnce());
+ expect(api.createVaultSecret.mock.calls[0][0]).not.toHaveProperty('fields');
+ expect(api.createVaultSecret.mock.calls[0][0]).not.toHaveProperty('default_field');
+});
+
+it('preserves a selected file instead of silently switching it to empty field rows', async () => {
+ const { container } = render(form(<VaultSecretForm fixedName="TOKEN" onCancel={vi.fn()} onCreated={vi.fn()} />));
+ fireEvent.click(screen.getByRole('radio', { name: 'File' }));
+ const file = new File(['secret bytes'], 'credential.bin');
+ fireEvent.change(container.querySelector('input[type="file"]')!, { target: { files: [file] } });
+ expect(screen.getByText('credential.bin')).toBeTruthy();
+ const add = screen.getByRole('button', { name: 'Add field' }) as HTMLButtonElement;
+ const template = screen.getByRole('button', { name: 'Login template' }) as HTMLButtonElement;
+ expect(add.disabled).toBe(true);
+ expect(template.disabled).toBe(true);
+ fireEvent.click(add);
+ fireEvent.click(template);
+ expect(screen.getByText('credential.bin')).toBeTruthy();
+ expect(screen.getByText(en.vaults.fields.singleFile)).toBeTruthy();
+ expect(screen.queryByLabelText('Field 1 name')).toBeNull();
+});
+
+it('seeds provision rows once, validates duplicate names, and permits removing extra rows', async () => {
+ const spec = { fields: ['username', 'password', 'totp'], default_field: 'password' };
+ const props = { fixedName: 'LOGIN', provisionRequestId: 'request', onCancel: vi.fn(), onCreated: vi.fn() };
+ const { rerender } = render(form(<VaultSecretForm {...props} requestSpec={spec} />));
+ change('Value for username', '用户');
+ change('Value for password', 'secret');
+ fireEvent.click(screen.getByRole('button', { name: 'Remove totp' }));
+ rerender(form(<VaultSecretForm {...props} requestSpec={{ ...spec }} />));
+ expect((screen.getByLabelText('Value for username') as HTMLInputElement).value).toBe('用户');
+ expect(screen.queryByLabelText('Value for totp')).toBeNull();
+ change('Field 1 name', 'password');
+ const submit = screen.getByRole('button', { name: 'Save & let the agent continue' }) as HTMLButtonElement;
+ expect(submit.disabled).toBe(true);
+ change('Field 1 name', 'user_name');
+ await waitFor(() => expect(submit.disabled).toBe(false));
+ fireEvent.click(submit);
+ await waitFor(() => expect(api.createVaultSecret).toHaveBeenCalledOnce());
+ expect(api.createVaultSecret.mock.calls[0][0].fields).toEqual([
+ { name: 'user_name', record: 'LOGIN.user_name', blind_box: blindBox },
+ ]);
+});
+
+it('does not overwrite edited metadata when a refreshed secret object arrives', () => {
+ const first: VaultSecret = {
+ name: 'LOGIN',
+ default_field: 'password',
+ fields: ['password', 'username'],
+ kind: 'static',
+ protection: 'standard',
+ signer_kind: null,
+ source: 'user',
+ tags: [],
+ policy: {},
+ description: 'server description',
+ last_used_at: null,
+ use_count: 0,
+ created_at: 'created',
+ updated_at: 'version-1',
+ };
+ const refreshed = { ...first, description: 'new server description', updated_at: 'version-2' };
+ const props = { onCancel: vi.fn(), onCreated: vi.fn(), editSecret: first };
+ const { rerender } = render(form(<VaultSecretForm {...props} />));
+ const description = screen.getByLabelText('Description') as HTMLInputElement;
+ fireEvent.change(description, { target: { value: 'local unsaved description' } });
+ rerender(form(<VaultSecretForm {...props} editSecret={refreshed} />));
+ expect((screen.getByLabelText('Description') as HTMLInputElement).value).toBe('local unsaved description');
+});
diff --git a/ui/src/components/ui/vault-secret-form.tsx b/ui/src/components/ui/vault-secret-form.tsx
index fbc44934f..b54706ba7 100644
--- a/ui/src/components/ui/vault-secret-form.tsx
+++ b/ui/src/components/ui/vault-secret-form.tsx
@@ -8,6 +8,7 @@ import {
FileText,
Loader2,
Lock,
+ Plus,
RefreshCw,
Server,
ShieldCheck,
@@ -24,6 +25,7 @@ import {
type SigningAddresses,
type VaultRequestSpec,
type VaultSecret,
+ type VaultCreatePayload,
type VaultWebAuthnRegistrationPayload,
} from '@/context/ApiContext';
import type { VaultSandboxSealResult } from '@/lib/vaultSandboxClient';
@@ -38,7 +40,9 @@ import {
type ProtectedRecordEnvelope,
type SigningKeyMaterial,
} from '@/lib/vaultCrypto';
+import { vaultErrorMessage } from '@/lib/vaultErrors';
import { useProtectedVault } from '@/lib/useProtectedVault';
+import { MAX_VAULT_FIELDS, VAULT_FIELD_PATTERN, vaultRecordName } from '@/lib/vaultFields';
import { openVaultsInBrowser } from '@/lib/vaultBrowserHandoff';
import { Badge } from './badge';
import { Button } from './button';
@@ -49,10 +53,12 @@ import { Switch } from './switch';
import { TagInput } from './tag-input';
import { Textarea } from './textarea';
import { VaultProtectedUnlock } from './vault-protected-unlock';
+import { VaultSecretFieldsEditor } from './vault-secret-fields-editor';
type VaultKind = 'static' | 'keypair';
type FetchAuthMode = 'bearer' | 'header' | 'query';
type StaticSecretSource = 'text' | 'file';
+type FieldDraft = { name: string; value: string };
const AVAULT_P2_MIN_VERSION = '0.1.3';
const MAX_SECRET_FILE_BYTES = 1024 * 1024;
@@ -132,7 +138,7 @@ export const VaultSecretForm: React.FC<{
provisionRequestId?: string | null;
requestSpec?: VaultRequestSpec | null;
treatExistingAsFulfilled?: boolean;
- /** When set, the form is in value-free edit mode for this existing secret. */
+ /** When set, metadata and individual field values can be edited. */
editSecret?: VaultSecret | null;
/** Called after a successful metadata edit (edit mode only). */
onSaved?: (name: string) => void;
@@ -155,6 +161,9 @@ export const VaultSecretForm: React.FC<{
const api = useApi();
const [name, setName] = useState(fixedName ?? '');
const [value, setValue] = useState('');
+ const [fieldRows, setFieldRows] = useState<FieldDraft[] | null>(null);
+ const [defaultFieldIndex, setDefaultFieldIndex] = useState(0);
+ const [fieldEditBusy, setFieldEditBusy] = useState(false);
const staticValueRef = useRef('');
const setStaticValue = useCallback((next: string) => {
staticValueRef.current = next;
@@ -289,13 +298,23 @@ export const VaultSecretForm: React.FC<{
if (requestSpec.policy?.allowed_hosts) setAllowHosts(requestSpec.policy.allowed_hosts);
if (requestSpec.policy?.auth?.type) setFetchAuthMode(requestSpec.policy.auth.type);
if (requestSpec.policy?.auth?.name) setFetchAuthName(requestSpec.policy.auth.name);
+ if (requestSpec.fields?.length) {
+ setFieldRows(requestSpec.fields.map((field) => ({ name: field, value: '' })));
+ setDefaultFieldIndex(Math.max(0, requestSpec.fields.indexOf(requestSpec.default_field ?? requestSpec.fields[0])));
+ }
}, [requestSpec, provisionRequestId]);
// Edit mode: seed editable metadata from the existing secret. Name / kind / protection are
// shown read-only (not seeded into editable controls); the value is never loaded; always_ask
// is neither seeded nor emitted — the backend preserves it (storage.update_secret_metadata).
+ const seededEditSecretRef = useRef<string | null>(null);
useEffect(() => {
- if (!editSecret) return;
+ if (!editSecret) {
+ seededEditSecretRef.current = null;
+ return;
+ }
+ if (seededEditSecretRef.current === editSecret.name) return;
+ seededEditSecretRef.current = editSecret.name;
setKind(editSecret.kind === 'keypair' ? 'keypair' : 'static');
setProtection(editSecret.protection === 'protected' ? 'protected' : 'standard');
const parts = partitionTags(editSecret.tags);
@@ -310,6 +329,7 @@ export const VaultSecretForm: React.FC<{
const p2Ready = useMemo(() => avaultP2Ready(avaultDep), [avaultDep]);
const secretName = (fixedName ?? name).trim();
+ const secretNameValid = /^[A-Za-z_][A-Za-z0-9_]*$/.test(secretName);
const protectedCreateReady = protectedVault.status === 'unlocked';
const isKeypair = kind === 'keypair';
const isProvision = Boolean(fixedName);
@@ -365,7 +385,10 @@ export const VaultSecretForm: React.FC<{
};
}, [signingKey, api]);
- const staticValueReady = staticSource === 'file' ? selectedFile != null && selectedFile.size > 0 : Boolean(value);
+ const staticValueReady = fieldRows
+ ? fieldRows.every((field) => field.value && VAULT_FIELD_PATTERN.test(field.name)) &&
+ new Set(fieldRows.map((field) => field.name)).size === fieldRows.length
+ : staticSource === 'file' ? selectedFile != null && selectedFile.size > 0 : Boolean(value);
const valueReady = isKeypair
? // Protected keypair must be generated in-sandbox first (below); standard keypair needs the
// locally-built signing key. Static readiness is the entered/selected value.
@@ -374,8 +397,8 @@ export const VaultSecretForm: React.FC<{
: signingKey != null
: staticValueReady;
const canSubmit = isEdit
- ? !submitting
- : Boolean(secretName && valueReady) &&
+ ? !submitting && !fieldEditBusy
+ : Boolean(secretNameValid && valueReady) &&
!submitting &&
// Block submit while a protected keypair is (re)generating in the sandbox, so the user can't
// submit the previous envelope mid-ceremony and persist a key they're actively replacing.
@@ -390,6 +413,7 @@ export const VaultSecretForm: React.FC<{
const clearStaticValue = useCallback(() => {
staticValueRef.current = '';
setValue('');
+ setFieldRows((rows) => rows?.map((row) => ({ ...row, value: '' })) ?? null);
clearSelectedFile();
}, [clearSelectedFile]);
@@ -469,7 +493,7 @@ export const VaultSecretForm: React.FC<{
// here. R1 semantics — silent while unlocked (the form's gate covers the locked case). Regenerate
// just calls again and discards the previous envelope.
const generateProtectedKeypair = async () => {
- if (!secretName || generatingKeypair) return;
+ if (!secretNameValid || generatingKeypair) return;
const gen = (keypairGenRef.current += 1);
setGeneratingKeypair(true);
setKeypairError(null);
@@ -556,7 +580,7 @@ export const VaultSecretForm: React.FC<{
});
const result = await api.updateVaultSecret(editSecret.name, patch, { handleError: false });
if (!result.ok) {
- setError(result.message || t('vaults.dialog.errors.updateFailed'));
+ setError(vaultErrorMessage(t, result, t('vaults.dialog.errors.updateFailed')));
return;
}
onSaved?.(editSecret.name);
@@ -606,7 +630,32 @@ export const VaultSecretForm: React.FC<{
let establishingVmk = false;
let authzFactorRegistration: Awaited<ReturnType<typeof protectedVault.sealValue>>['authzFactorRegistration'];
let protectedPublicMeta: Record<string, unknown> | undefined;
- if (protection === 'protected') {
+ let extraFields: VaultCreatePayload['fields'];
+ if (!isKeypair && fieldRows) {
+ extraFields = [];
+ const defaultField = fieldRows[defaultFieldIndex].name;
+ const pubkey = protection === 'standard' ? await api.getVaultPubkey() : null;
+ let defaultCrypto: typeof cryptoFields | undefined;
+ for (const [index, row] of fieldRows.entries()) {
+ const record = vaultRecordName(secretName, row.name, defaultField);
+ let fieldCrypto: typeof cryptoFields;
+ if (protection === 'protected') {
+ const valueRef = { current: row.value };
+ const sealed = await protectedVault.sealValue(record, 'static', {
+ valueRef,
+ clear: () => setFieldRows((rows) => rows?.map((field, i) => i === index ? { ...field, value: '' } : field) ?? null),
+ });
+ fieldCrypto = { sealed: sealed.envelope };
+ establishingVmk ||= sealed.establishingVmk;
+ authzFactorRegistration ??= sealed.authzFactorRegistration;
+ } else {
+ fieldCrypto = { blind_box: await sealBlindBox(row.value, pubkey!, standardCreateBlindBoxContext(record)) };
+ }
+ if (index === defaultFieldIndex) defaultCrypto = fieldCrypto;
+ else extraFields.push({ name: row.name, record, ...fieldCrypto });
+ }
+ cryptoFields = defaultCrypto!;
+ } else if (protection === 'protected') {
if (isKeypair) {
// Keypair was already sealed in-sandbox by "Generate key" (protocol v2 §7.2). Submit the
// held envelope + public metadata; no second seal, and the private key never existed here.
@@ -657,6 +706,7 @@ export const VaultSecretForm: React.FC<{
...base,
...(protectedPublicMeta ? { kind: 'keypair', signer_kind: 'local', public_meta: protectedPublicMeta } : {}),
...cryptoFields,
+ ...(!isKeypair && fieldRows ? { default_field: fieldRows[defaultFieldIndex].name, fields: extraFields } : {}),
...(establishingVmk
? {
establishing_vmk: true,
@@ -682,7 +732,7 @@ export const VaultSecretForm: React.FC<{
setError(t('vaults.protectedUnlock.errors.alreadyInitialized'));
return;
}
- throw new Error(created.message || created.code || t('vaults.request.saveFailed'));
+ throw new Error(vaultErrorMessage(t, created, t('vaults.request.saveFailed')));
}
if (protection === 'protected') protectedVault.afterCreated();
clearStaticValue();
@@ -706,7 +756,7 @@ export const VaultSecretForm: React.FC<{
} else if (err instanceof ApiError && err.code === 'secret_name_case_conflict') {
setError(err.message || t('vaults.dialog.errors.secretNameCaseConflict'));
} else {
- setError(err instanceof Error ? err.message : String(err));
+ setError(vaultErrorMessage(t, err, t('vaults.request.saveFailed')));
}
} finally {
fileBytesToWipe?.fill(0);
@@ -804,6 +854,70 @@ export const VaultSecretForm: React.FC<{
</div>
);
+ const staticFields = (
+ <div className="flex flex-col gap-2">
+ {fieldRows ? (
+ <div className="flex flex-col gap-3">
+ {fieldRows.map((field, index) => (
+ <div key={index} className="flex flex-col gap-2 rounded-lg border border-border p-3">
+ <div className="flex items-center gap-2">
+ <Input
+ value={field.name}
+ onChange={(event) => setFieldRows((rows) => rows!.map((row, i) => i === index ? { ...row, name: event.target.value } : row))}
+ aria-label={t('vaults.fields.name', { index: index + 1 })}
+ placeholder={t('vaults.fields.namePlaceholder')}
+ pattern={VAULT_FIELD_PATTERN.source}
+ maxLength={64}
+ required
+ disabled={submitting}
+ className="min-w-0 font-mono"
+ />
+ <label className="flex shrink-0 items-center gap-1 text-xs text-muted">
+ <input type="radio" name="default-field" checked={index === defaultFieldIndex} disabled={submitting}
+ onChange={() => setDefaultFieldIndex(index)} />
+ {t('vaults.fields.default')}
+ </label>
+ <Button type="button" variant="ghost" size="icon" disabled={submitting || index === defaultFieldIndex}
+ aria-label={t('vaults.fields.remove', { field: field.name })}
+ onClick={() => {
+ setFieldRows((rows) => rows!.filter((_, i) => i !== index));
+ if (index < defaultFieldIndex) setDefaultFieldIndex(defaultFieldIndex - 1);
+ }}>
+ <X className="size-4" />
+ </Button>
+ </div>
+ <Input type="password" value={field.value} autoComplete="off" spellCheck={false} required disabled={submitting}
+ aria-label={t('vaults.fields.value', { field: field.name || index + 1 })}
+ placeholder={t('vaults.dialog.valuePlaceholder')}
+ onChange={(event) => setFieldRows((rows) => rows!.map((row, i) => i === index ? { ...row, value: event.target.value } : row))} />
+ </div>
+ ))}
+ <span className="text-[11px] text-muted-foreground">{t('vaults.fields.namesHelp')}</span>
+ </div>
+ ) : valueField}
+ <div className="flex gap-2">
+ <Button type="button" variant="ghost" size="sm" disabled={submitting || staticSource === 'file' || (fieldRows?.length ?? 1) >= MAX_VAULT_FIELDS}
+ onClick={() => {
+ setFieldRows((rows) => [...(rows ?? [{ name: 'value', value }]), { name: '', value: '' }]);
+ setStaticValue('');
+ setStaticSource('text');
+ clearSelectedFile();
+ }}>
+ <Plus className="size-3.5" />{t('vaults.fields.add')}
+ </Button>
+ {!fieldRows && <Button type="button" variant="ghost" size="sm" disabled={submitting || staticSource === 'file'}
+ onClick={() => {
+ setFieldRows([{ name: 'username', value: '' }, { name: 'password', value }, { name: 'totp', value: '' }]);
+ setDefaultFieldIndex(1);
+ setStaticValue('');
+ setStaticSource('text');
+ clearSelectedFile();
+ }}>{t('vaults.fields.loginTemplate')}</Button>}
+ </div>
+ {staticSource === 'file' && <span className="text-[11px] text-muted-foreground">{t('vaults.fields.singleFile')}</span>}
+ </div>
+ );
+
const fetchAuthPolicyFields = (
<div className="flex flex-col gap-1.5">
<span className={FIELD_LABEL}>{t('vaults.dialog.fetchAuth')}</span>
@@ -1003,9 +1117,7 @@ export const VaultSecretForm: React.FC<{
</div>
);
- // ---- Edit mode — value-free metadata edit of an existing secret --------------------
- // Name / kind / protection / value are immutable and shown read-only; only description, tags
- // (incl. `skill:` tags) and — for a static secret — the fetch proxy policy are editable.
+ // Field writes save independently; the form submit updates shared metadata.
if (isEdit && editSecret) {
return (
<form className={cn('flex min-w-0 flex-col gap-4', className)} onSubmit={onSubmit}>
@@ -1027,6 +1139,7 @@ export const VaultSecretForm: React.FC<{
<Lock className="size-3 shrink-0" />
{t('vaults.edit.lockedHint')}
</p>
+ {!isKeypair && <VaultSecretFieldsEditor key={editSecret.name} secret={editSecret} disabled={submitting} onBusyChange={setFieldEditBusy} />}
<label className="flex flex-col gap-1.5">
<span className={FIELD_LABEL}>{t('vaults.dialog.description')}</span>
@@ -1046,7 +1159,7 @@ export const VaultSecretForm: React.FC<{
)}
<div className="mt-1 flex justify-end gap-2">
- <Button type="button" variant="ghost" onClick={onCancel} disabled={submitting}>
+ <Button type="button" variant="ghost" onClick={onCancel} disabled={submitting || fieldEditBusy}>
{cancelLabel ?? t('vaults.dialog.cancel')}
</Button>
<Button type="submit" disabled={!canSubmit}>
@@ -1076,11 +1189,11 @@ export const VaultSecretForm: React.FC<{
</div>
{!isKeypair && (
- <label className="flex flex-col gap-1.5">
+ <div className="flex flex-col gap-1.5">
<span className={FIELD_LABEL}>{t('vaults.dialog.value')}</span>
- {valueField}
+ {staticFields}
<span className="text-[11px] text-muted-foreground">{t('vaults.dialog.provisionValueHelp')}</span>
- </label>
+ </div>
)}
<label className="flex flex-col gap-1.5">
@@ -1139,6 +1252,8 @@ export const VaultSecretForm: React.FC<{
setSigningError(null);
} else {
clearStaticValue();
+ setFieldRows(null);
+ setDefaultFieldIndex(0);
}
// A sandbox-sealed protected keypair is bound to its kind; switching kind invalidates it.
clearProtectedKeypair();
@@ -1172,10 +1287,10 @@ export const VaultSecretForm: React.FC<{
{/* Value (static) or signing-key builder (keypair) */}
{!isKeypair && (
- <label className="flex flex-col gap-1.5">
+ <div className="flex flex-col gap-1.5">
<span className={FIELD_LABEL}>{t('vaults.dialog.value')}</span>
- {valueField}
- </label>
+ {staticFields}
+ </div>
)}
{isKeypair && protection === 'standard' && (
@@ -1285,7 +1400,7 @@ export const VaultSecretForm: React.FC<{
<Button
type="button"
variant="secondary"
- disabled={submitting || generatingKeypair || !secretName}
+ disabled={submitting || generatingKeypair || !secretNameValid}
onClick={() => void generateProtectedKeypair()}
>
{generatingKeypair ? <Loader2 className="size-4 animate-spin" /> : <RefreshCw className="size-4" />}
diff --git a/ui/src/components/workbench/VaultsPage.test.tsx b/ui/src/components/workbench/VaultsPage.test.tsx
index 222e40d8d..433b51084 100644
--- a/ui/src/components/workbench/VaultsPage.test.tsx
+++ b/ui/src/components/workbench/VaultsPage.test.tsx
@@ -7,12 +7,15 @@ import userEvent from '@testing-library/user-event';
import { MemoryRouter } from 'react-router-dom';
import { InstanceAuthorizationContext } from '../../context/InstanceAuthorizationContext';
+import { ApiError } from '../../context/ApiContext';
import { OWNER_INSTANCE_CAPABILITIES } from '../../lib/sessionInfo';
+import zh from '../../i18n/zh.json';
import { VaultsPage } from './VaultsPage';
type WorkbenchEventHandlers = { onVaultsUpdated?: (data: unknown) => void };
const eventHandlers = vi.hoisted(() => [] as WorkbenchEventHandlers[]);
+const testTranslation = vi.hoisted(() => ({ locale: 'keys' as 'keys' | 'zh' }));
const api = vi.hoisted(() => ({
connectWorkbenchEvents: vi.fn(() => () => undefined),
createVaultRevealContext: vi.fn(),
@@ -59,9 +62,18 @@ vi.mock('../../lib/useProtectedVault', () => ({
useVaultLock: () => ({ unlocked: false, remainingMs: 0, lockNow: vi.fn() }),
}));
-vi.mock('react-i18next', () => ({
- useTranslation: () => ({ t: (key: string) => key }),
-}));
+vi.mock('react-i18next', async () => {
+ const { default: catalog } = await import('../../i18n/zh.json');
+ const localized: Record<string, string> = {
+ 'errors.fields_corrupt': catalog.errors.fields_corrupt,
+ 'vaults.reveal.errors.contextFailed': catalog.vaults.reveal.errors.contextFailed,
+ };
+ return {
+ useTranslation: () => ({
+ t: (key: string) => testTranslation.locale === 'zh' ? localized[key] ?? key : key,
+ }),
+ };
+});
vi.mock('./CapabilityTabs', () => ({
CapabilityTabs: () => <div data-testid="capability-tabs" />,
@@ -76,10 +88,20 @@ vi.mock('./WorkbenchPageHeader', () => ({
),
}));
-function renderPage(context = remoteOwner) {
+vi.mock('../ui/vault-secret-dialog', () => ({
+ VaultSecretDialog: ({
+ open,
+ editSecret,
+ }: {
+ open: boolean;
+ editSecret?: { name: string; updated_at: string } | null;
+ }) => open ? <div data-testid="vault-edit-dialog">{editSecret?.name}:{editSecret?.updated_at}</div> : null,
+}));
+
+function renderPage(context = remoteOwner, initialEntries = ['/vaults']) {
return render(
<InstanceAuthorizationContext.Provider value={context}>
- <MemoryRouter initialEntries={['/vaults']}>
+ <MemoryRouter initialEntries={initialEntries}>
<VaultsPage />
</MemoryRouter>
</InstanceAuthorizationContext.Provider>,
@@ -105,6 +127,7 @@ beforeEach(() => {
afterEach(() => {
cleanup();
+ testTranslation.locale = 'keys';
vi.clearAllMocks();
vi.restoreAllMocks();
});
@@ -126,6 +149,19 @@ describe('VaultsPage remote audit history', () => {
expect(await screen.findByText('alpha')).toBeTruthy();
});
+ it('shows a single custom field label without offering a field selector', async () => {
+ api.listVaultSecrets.mockResolvedValue({
+ secrets: [{
+ name: 'LOGIN', default_field: 'password', fields: ['password'], kind: 'static', protection: 'standard',
+ signer_kind: null, source: 'user', tags: [], policy: {}, last_used_at: null, use_count: 0,
+ created_at: 'created', updated_at: 'version-1',
+ }],
+ });
+ renderPage();
+ expect(await screen.findByText(/password/)).toBeTruthy();
+ expect(screen.queryByRole('combobox')).toBeNull();
+ });
+
it('shows Vault management controls to an Editor', async () => {
renderPage(activeOrgMember);
@@ -134,6 +170,39 @@ describe('VaultsPage remote audit history', () => {
});
});
+describe('VaultsPage edit metadata freshness', () => {
+ it('passes the refreshed list entry to an already-open edit dialog', async () => {
+ const original = {
+ name: 'LOGIN',
+ default_field: 'password',
+ fields: ['password', 'username'],
+ kind: 'static',
+ protection: 'standard',
+ signer_kind: null,
+ source: 'user',
+ tags: [],
+ policy: {},
+ last_used_at: null,
+ use_count: 0,
+ created_at: 'created',
+ updated_at: 'version-1',
+ };
+ const refreshed = { ...original, updated_at: 'version-2' };
+ api.listVaultSecrets.mockResolvedValue({ secrets: [original] });
+ renderPage();
+ await screen.findByText('LOGIN');
+ fireEvent.click(await screen.findByRole('button', { name: 'vaults.rowActions' }));
+ fireEvent.click(screen.getByRole('menuitem', { name: 'vaults.editSecret' }));
+ expect((await screen.findByTestId('vault-edit-dialog')).textContent).toBe('LOGIN:version-1');
+
+ api.listVaultSecrets.mockResolvedValue({ secrets: [refreshed] });
+ await act(async () => {
+ for (const handler of [...eventHandlers]) handler.onVaultsUpdated?.({});
+ });
+ expect((await screen.findByTestId('vault-edit-dialog')).textContent).toBe('LOGIN:version-2');
+ });
+});
+
// PERMISSIONS-016 — `vaults.updated` is admitted at the Editor tier that owns
// the endpoint it announces, and below runtime management the controller reduces
// the frame to its type alone. The pending-requests list is the consumer that
@@ -230,6 +299,38 @@ describe('VaultsPage protected reveal', () => {
expect(api.createVaultRevealContext).toHaveBeenCalledTimes(fetches);
});
+ it('shows the localized corruption warning on a row while keeping default reveal available', async () => {
+ testTranslation.locale = 'zh';
+ api.listVaultSecrets.mockResolvedValue({
+ secrets: [{ ...protectedSecret('alpha'), fields_state: 'corrupt' }],
+ });
+ api.createVaultRevealContext.mockResolvedValue({ ok: true, context: { secret_name: 'alpha' }, envelope });
+ await openMenu();
+ expect((await screen.findByRole('alert')).textContent).toBe(zh.errors.fields_corrupt);
+ expect(screen.getByRole('menuitem', { name: 'vaults.reveal.show' })).toBeTruthy();
+ });
+
+ it.each(['response', 'exception'] as const)('localizes a reveal context failure from a %s in Chinese', async (failure) => {
+ testTranslation.locale = 'zh';
+ if (failure === 'response') {
+ api.createVaultRevealContext.mockResolvedValue({
+ ok: false,
+ code: 'fields_corrupt',
+ message: 'English service detail',
+ });
+ } else {
+ api.createVaultRevealContext.mockRejectedValue(
+ new ApiError('English service detail', 409, 'fields_corrupt'),
+ );
+ }
+ const popup = { closed: false, close: vi.fn() };
+ vi.spyOn(window, 'open').mockReturnValue(popup as unknown as Window);
+ await openMenu();
+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledOnce());
+ fireEvent.click(showValue());
+ await vi.waitFor(() => expect(showToast).toHaveBeenCalledWith(zh.errors.fields_corrupt, 'warning'));
+ });
+
it('keeps Show value waiting while the context or the sandbox client are not ready', async () => {
let answer: () => void = () => undefined;
api.createVaultRevealContext.mockImplementation(
@@ -265,6 +366,97 @@ describe('VaultsPage protected reveal', () => {
expect(revealProtectedValue.mock.calls[0][1]).toEqual({ secret_name: 'beta' });
});
+ // A field switch needs its own prepared context. The single-secret cases above cannot detect
+ // displaying the default envelope for an extra field, or using NAME.password as a default record.
+ it.each([
+ { field: 'password', record: 'alpha' },
+ { field: 'username', record: 'alpha.username' },
+ ])('reveals $field with its own context and canonical record', async ({ field, record }) => {
+ api.listVaultSecrets.mockResolvedValue({
+ secrets: [{ ...protectedSecret('alpha'), default_field: 'password', fields: ['password', 'username'] }],
+ });
+ api.createVaultRevealContext.mockImplementation(async (_name, payload) => ({
+ ok: true, context: { field: payload.field }, envelope,
+ }));
+ await openMenu();
+ fireEvent.change(screen.getByRole('combobox', { name: 'vaults.fields.revealField' }), { target: { value: field } });
+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenLastCalledWith(
+ 'alpha', { session_label: 'vaults.title', field },
+ ));
+ await clickShowValue();
+ expect(revealProtectedValue.mock.calls[0][0].name).toBe(record);
+ expect(revealProtectedValue.mock.calls[0][1]).toEqual({ field });
+ });
+
+ it('shows a stale handoff field without preparing or revealing the default field', async () => {
+ api.listVaultSecrets.mockResolvedValue({
+ secrets: [{ ...protectedSecret('alpha'), default_field: 'password', fields: ['password'] }],
+ });
+ renderPage(remoteOwner, ['/vaults?reveal=alpha&field=username']);
+
+ expect((await screen.findByRole('alert')).textContent).toBe('vaults.reveal.errors.staleField');
+ expect(api.createVaultRevealContext).not.toHaveBeenCalled();
+ expect(revealProtectedValue).not.toHaveBeenCalled();
+ });
+
+ it('keeps a disappearing active field stale without preparing the default field', async () => {
+ const initial = { ...protectedSecret('alpha'), default_field: 'password', fields: ['password', 'username'] };
+ api.listVaultSecrets.mockResolvedValue({ secrets: [initial] });
+ api.createVaultRevealContext.mockResolvedValue({ ok: true, context: { field: 'ready' }, envelope });
+ renderPage();
+ const user = userEvent.setup();
+ await user.click((await screen.findByRole('button', { name: 'vaults.rowActions' })));
+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledOnce());
+ fireEvent.change(screen.getByRole('combobox', { name: 'vaults.fields.revealField' }), { target: { value: 'username' } });
+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledTimes(2));
+ const preparedBeforeRefresh = api.createVaultRevealContext.mock.calls.length;
+
+ api.listVaultSecrets.mockResolvedValue({
+ secrets: [{ ...initial, fields: ['password'] }],
+ });
+ await act(async () => {
+ for (const handler of [...eventHandlers]) handler.onVaultsUpdated?.({});
+ });
+
+ expect((await screen.findByRole('alert')).textContent).toBe('vaults.reveal.errors.staleField');
+ expect(api.createVaultRevealContext).toHaveBeenCalledTimes(preparedBeforeRefresh);
+ });
+
+ it('refreshes a prepared extra-field context when only the default label changes', async () => {
+ const entry = { ...protectedSecret('alpha'), default_field: 'password', fields: ['password', 'username'] };
+ api.listVaultSecrets.mockResolvedValue({ secrets: [entry] });
+ api.createVaultRevealContext.mockResolvedValue({ ok: true, context: { label: 'password' }, envelope });
+ await openMenu();
+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledOnce());
+ fireEvent.change(screen.getByRole('combobox', { name: 'vaults.fields.revealField' }), { target: { value: 'username' } });
+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledTimes(2));
+ api.listVaultSecrets.mockResolvedValue({ secrets: [{ ...entry, default_field: 'credential', fields: ['credential', 'username'] }] });
+ api.createVaultRevealContext.mockResolvedValue({ ok: true, context: { label: 'credential' }, envelope });
+ await act(async () => {
+ for (const handler of eventHandlers) handler.onVaultsUpdated?.({ scope: 'secret', secret_name: 'alpha' });
+ });
+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledTimes(3));
+ await clickShowValue();
+ expect(revealProtectedValue.mock.calls[0][1]).toEqual({ label: 'credential' });
+ });
+
+ it('prepares the replacement envelope when an open secret changes version', async () => {
+ let version = 'old';
+ api.createVaultRevealContext.mockImplementation(async () => ({ ok: true, context: { version }, envelope }));
+ await openMenu();
+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledOnce());
+ version = 'new';
+ api.listVaultSecrets.mockResolvedValue({
+ secrets: [{ ...protectedSecret('alpha'), updated_at: '2026-10-13T12:00:00Z' }],
+ });
+ await act(async () => {
+ for (const handler of eventHandlers) handler.onVaultsUpdated?.({ scope: 'secret', secret_name: 'alpha' });
+ });
+ await vi.waitFor(() => expect(api.createVaultRevealContext).toHaveBeenCalledTimes(2));
+ await clickShowValue();
+ expect(revealProtectedValue.mock.calls[0][1]).toEqual({ version: 'new' });
+ });
+
it('refreshes the context while the menu stays open, so the click fetches nothing', async () => {
let fetched = 0;
api.createVaultRevealContext.mockImplementation(async () => ({ ok: true, context: { fetch: ++fetched }, envelope }));
diff --git a/ui/src/components/workbench/VaultsPage.tsx b/ui/src/components/workbench/VaultsPage.tsx
index 6f0ecb598..9f107b98a 100644
--- a/ui/src/components/workbench/VaultsPage.tsx
+++ b/ui/src/components/workbench/VaultsPage.tsx
@@ -13,6 +13,8 @@ import { VaultLockIndicator } from '../ui/vault-lock-indicator';
import { onPageReactivated } from '../../lib/pageActivity';
import { cn } from '../../lib/utils';
import { partitionTags } from '../../lib/vaultTags';
+import { vaultDefaultField, vaultFieldFingerprint, vaultFieldNames, vaultHasNamedFieldShape, vaultRecordName } from '../../lib/vaultFields';
+import { vaultErrorMessage } from '../../lib/vaultErrors';
import {
useApi,
type VaultAuditEvent,
@@ -62,19 +64,26 @@ const SecretRow: React.FC<{
secret: VaultSecret;
onEdit: (secret: VaultSecret) => void;
onDelete: (secret: VaultSecret) => void;
- onReveal: (secret: VaultSecret) => void;
+ onReveal: (secret: VaultSecret, field: string) => void;
+ revealField: string | null;
+ onRevealFieldChange: (field: string) => void;
canManage: boolean;
menuOpen: boolean;
onMenuOpenChange: (open: boolean) => void;
/** The open menu's reveal context or sandbox client is not ready yet. */
revealPreparing: boolean;
-}> = ({ secret: s, onEdit, onDelete, onReveal, canManage, menuOpen, onMenuOpenChange: setMenuOpen, revealPreparing }) => {
+}> = ({ secret: s, onEdit, onDelete, onReveal, revealField, onRevealFieldChange, canManage, menuOpen, onMenuOpenChange: setMenuOpen, revealPreparing }) => {
const { t } = useTranslation();
const isKeypair = s.kind === 'keypair';
const isProtected = s.protection === 'protected';
// Reveal is only meaningful for a protected static secret: its plaintext lives sealed and can be
// shown in-sandbox. Standard values aren't sandbox-sealed, and a keypair has no plaintext value.
const canReveal = isProtected && !isKeypair;
+ const fields = vaultFieldNames(s);
+ const selectedField = revealField === null
+ ? vaultDefaultField(s)
+ : fields.includes(revealField) ? revealField : null;
+ const staleRevealField = canReveal && selectedField === null;
// The sandbox reveal needs its authorization window, which only a browser can pair with.
const revealInBrowser = canReveal && vaultPasskeyNeedsBrowser();
// Skills are stored as reserved `skill:<name>` tags; render them as their own chips.
@@ -124,7 +133,17 @@ const SecretRow: React.FC<{
{s.description ? `${s.description} · ` : ''}
{s.last_used_at ? t('vaults.used', { count: s.use_count }) : t('vaults.neverUsed')}
</span>
+ {s.fields_state === 'corrupt' && (
+ <span role="alert" className="text-xs text-destructive-ink">{t('errors.fields_corrupt')}</span>
+ )}
{isKeypair && s.signing_addresses ? <SigningAddressList addresses={s.signing_addresses} className="mt-1" /> : null}
+ {!isKeypair && vaultHasNamedFieldShape(s) && (
+ <div className="flex flex-wrap gap-1">
+ {fields.map((field) => <Badge key={field} variant="outline" className="font-mono">
+ {field}{field === vaultDefaultField(s) ? ` · ${t('vaults.fields.default')}` : ''}
+ </Badge>)}
+ </div>
+ )}
</div>
{canManage ? <div className="ml-auto">
<Popover open={menuOpen} onOpenChange={setMenuOpen}>
@@ -134,14 +153,30 @@ const SecretRow: React.FC<{
</Button>
</PopoverTrigger>
<PopoverContent align="end" className="w-44 p-1" role="menu">
- {revealInBrowser ? (
+ {/* Choice-only: a single custom field is displayed above but needs no selector. */}
+ {canReveal && fields.length > 1 && (
+ <label className="flex flex-col gap-1 px-2.5 py-2 text-xs text-muted">
+ {t('vaults.fields.revealField')}
+ <select value={selectedField ?? ''} onChange={(event) => onRevealFieldChange(event.target.value)}
+ className="rounded-md border border-border bg-surface px-2 py-1 font-mono text-foreground">
+ {fields.map((field) => <option key={field} value={field}>{field}</option>)}
+ </select>
+ </label>
+ )}
+ {staleRevealField && (
+ <p role="alert" className="px-2.5 py-2 text-xs text-destructive-ink">
+ {t('vaults.reveal.errors.staleField')}
+ </p>
+ )}
+ {!staleRevealField && revealInBrowser ? (
<>
<button
type="button"
role="menuitem"
onClick={() => {
+ if (!selectedField) return;
setMenuOpen(false);
- openVaultsInBrowser({ kind: 'reveal', secretName: s.name });
+ openVaultsInBrowser({ kind: 'reveal', secretName: s.name, field: selectedField });
}}
className="flex w-full items-center gap-2 rounded-md px-2.5 py-2 text-left text-sm text-foreground transition-colors hover:bg-surface-2"
>
@@ -150,7 +185,7 @@ const SecretRow: React.FC<{
</button>
<div className="my-1 h-px bg-border" />
</>
- ) : canReveal ? (
+ ) : !staleRevealField && canReveal ? (
<>
{/* Reveal opens the value inside the sandbox frame; the plaintext is never returned
to Avibe. "Copy value" leads to the same sandbox card, where copying is the
@@ -160,8 +195,9 @@ const SecretRow: React.FC<{
role="menuitem"
disabled={revealPreparing}
onClick={() => {
+ if (!selectedField) return;
setMenuOpen(false);
- onReveal(s);
+ onReveal(s, selectedField);
}}
className="flex w-full items-center gap-2 rounded-md px-2.5 py-2 text-left text-sm text-foreground transition-colors hover:bg-surface-2 disabled:cursor-default disabled:opacity-50 disabled:hover:bg-transparent"
>
@@ -173,8 +209,9 @@ const SecretRow: React.FC<{
role="menuitem"
disabled={revealPreparing}
onClick={() => {
+ if (!selectedField) return;
setMenuOpen(false);
- onReveal(s);
+ onReveal(s, selectedField);
}}
className="flex w-full items-center gap-2 rounded-md px-2.5 py-2 text-left text-sm text-foreground transition-colors hover:bg-surface-2 disabled:cursor-default disabled:opacity-50 disabled:hover:bg-transparent"
>
@@ -569,6 +606,7 @@ export const VaultsPage: React.FC = () => {
const step = useMemo(() => readVaultBrowserStep(searchParams), [searchParams]);
// The secret whose row menu is open; a reveal handed off from the desktop app reopens it.
const [menuSecret, setMenuSecret] = useState<string | null>(null);
+ const [menuField, setMenuField] = useState<string | null>(null);
const clearStep = useCallback(() => {
setSearchParams((prev) => withoutVaultBrowserStep(prev), { replace: true });
@@ -585,6 +623,7 @@ export const VaultsPage: React.FC = () => {
useEffect(() => {
if (!canManage || step?.kind !== 'reveal' || !secrets.some((s) => s.name === step.secretName)) return;
setMenuSecret(step.secretName);
+ setMenuField(step.field ?? null);
clearStep();
}, [canManage, step, secrets, clearStep]);
@@ -733,6 +772,16 @@ export const VaultsPage: React.FC = () => {
const [deleteTarget, setDeleteTarget] = useState<VaultSecret | null>(null);
const [editTarget, setEditTarget] = useState<VaultSecret | null>(null);
+ const activeEditSecret = editTarget
+ ? secrets.find((entry) => entry.name === editTarget.name) ?? editTarget
+ : null;
+ useEffect(() => {
+ if (!canManage || step?.kind !== 'edit') return;
+ const secret = secrets.find((entry) => entry.name === step.secretName);
+ if (!secret) return;
+ setEditTarget(secret);
+ clearStep();
+ }, [canManage, step, secrets, clearStep]);
const onDelete = (secret: VaultSecret) => setDeleteTarget(secret);
const onEdit = (secret: VaultSecret) => setEditTarget(secret);
@@ -743,35 +792,47 @@ export const VaultsPage: React.FC = () => {
// the daemon after the click (`usePreparedRequest`), so the open row menu keeps the context and the
// sandbox client ready, and the click claims them.
const requestRevealContext = useCallback(
- (name: string) => api.createVaultRevealContext(name, { session_label: t('vaults.title') }),
+ ({ name, field }: { name: string; field: string; version: string }) => api.createVaultRevealContext(name, { session_label: t('vaults.title'), field }),
[api, t],
);
- const menuRevealName = useMemo(() => {
+ const menuRevealKey = useMemo(() => {
const secret = secrets.find((s) => s.name === menuSecret);
- return secret?.protection === 'protected' && secret.kind !== 'keypair' && !vaultPasskeyNeedsBrowser() ? secret.name : null;
- }, [secrets, menuSecret]);
- const revealContext = usePreparedRequest(menuRevealName, requestRevealContext, revealContextIssued, PREPARED_REVEAL);
- const revealSandboxReady = useVaultSandboxWarm(menuRevealName !== null);
+ if (secret?.protection !== 'protected' || secret.kind === 'keypair' || vaultPasskeyNeedsBrowser()) return null;
+ if (menuField !== null && !vaultFieldNames(secret).includes(menuField)) return null;
+ return {
+ name: secret.name,
+ field: menuField ?? vaultDefaultField(secret),
+ version: vaultFieldFingerprint(secret),
+ };
+ }, [secrets, menuSecret, menuField]);
+ const revealContext = usePreparedRequest(menuRevealKey, requestRevealContext, revealContextIssued, PREPARED_REVEAL);
+ const revealSandboxReady = useVaultSandboxWarm(menuRevealKey !== null);
// Show and Copy wait for both, so their click never waits on either.
const revealPreparing = !revealSandboxReady || revealContext.pending;
const revealSecret = useCallback(
- async (secret: VaultSecret) => {
+ async (secret: VaultSecret, field: string) => {
const authorizationWindow = openVaultAuthorizationWindow();
try {
- const res = await revealContext.claim(secret.name);
- if (!res?.ok || !res.context) throw new Error(res?.message || t('vaults.reveal.errors.contextFailed'));
+ const res = await revealContext.claim({ name: secret.name, field, version: vaultFieldFingerprint(secret) });
+ if (!res?.ok || !res.context) {
+ const message = vaultErrorMessage(t, res, t('vaults.reveal.errors.contextFailed'));
+ const code = typeof res === 'object' && res !== null && 'code' in res && typeof res.code === 'string'
+ ? res.code
+ : null;
+ throw Object.assign(new Error(message), code ? { code } : {});
+ }
// The sandbox needs the sealed record to open it. The daemon returns it alongside the signed
// reveal context; if it's absent, surface a clear message rather than a cryptic sandbox error.
if (!res.envelope) throw new Error(t('vaults.reveal.errors.unavailable'));
const wrapMeta =
typeof res.envelope.wrap_meta === 'string' ? res.envelope.wrap_meta : JSON.stringify(res.envelope.wrap_meta);
await vault.revealProtectedValue(
- { name: secret.name, kind: 'static', envelope: { ciphertext: res.envelope.ciphertext, nonce: res.envelope.nonce, wrap_meta: wrapMeta } },
+ { name: vaultRecordName(secret.name, field, vaultDefaultField(secret)), kind: 'static', envelope: { ciphertext: res.envelope.ciphertext, nonce: res.envelope.nonce, wrap_meta: wrapMeta } },
res.context,
authorizationWindow?.id,
);
} catch (err: unknown) {
- showToast(messageFromError(err), 'warning');
+ showToast(vaultErrorMessage(t, err, t('vaults.reveal.errors.contextFailed')), 'warning');
} finally {
authorizationWindow?.close();
}
@@ -935,10 +996,15 @@ export const VaultsPage: React.FC = () => {
onEdit={onEdit}
onDelete={onDelete}
onReveal={revealSecret}
+ revealField={s.name === menuSecret ? menuField : null}
+ onRevealFieldChange={setMenuField}
canManage={canManage}
menuOpen={s.name === menuSecret}
- revealPreparing={s.name === menuRevealName && revealPreparing}
- onMenuOpenChange={(open) => setMenuSecret(open ? s.name : null)}
+ revealPreparing={s.name === menuRevealKey?.name && revealPreparing}
+ onMenuOpenChange={(open) => {
+ setMenuSecret(open ? s.name : null);
+ setMenuField(null);
+ }}
/>
))}
</div>
@@ -977,8 +1043,8 @@ export const VaultsPage: React.FC = () => {
}}
/> : null}
{canManage ? <VaultSecretDialog
- open={editTarget != null}
- editSecret={editTarget}
+ open={activeEditSecret != null}
+ editSecret={activeEditSecret}
onOpenChange={(o) => {
if (!o) setEditTarget(null);
}}
diff --git a/ui/src/context/ApiContext.tsx b/ui/src/context/ApiContext.tsx
index e9de3f840..e0b76f38b 100644
--- a/ui/src/context/ApiContext.tsx
+++ b/ui/src/context/ApiContext.tsx
@@ -82,6 +82,11 @@ export type SigningAddresses = {
export type VaultSecret = {
name: string;
+ /** Absent on legacy servers; the default record is always the bare secret name. */
+ default_field?: string;
+ fields?: string[];
+ /** Present only when the stored extra-field section could not be read safely. */
+ fields_state?: 'corrupt';
/** Flat tag list; skill association is a reserved `skill:<name>` tag (see lib/vaultTags). */
tags: string[];
kind: string;
@@ -134,6 +139,8 @@ export type VaultRequestSession = {
export type VaultRequestSpec = {
kind?: 'static';
+ default_field?: string;
+ fields?: string[];
protection?: 'standard' | 'protected';
description?: string;
/** May already include `skill:<name>` tags; `links.skills` is a bare-name convenience mirror. */
@@ -358,6 +365,8 @@ export type VaultWebAuthnRegistrationPayload = {
export type VaultCreatePayload = {
name: string;
+ default_field?: string;
+ fields?: VaultCreateFieldPayload[];
protection?: 'standard' | 'protected';
blind_box?: VaultBlindBox;
sealed?: VaultSealedEnvelope;
@@ -387,11 +396,28 @@ export type VaultCreatePayload = {
* such as `always_ask`. Name / kind / protection / value are never editable through this path.
*/
export type VaultMetadataUpdatePayload = {
+ default_field?: string;
description?: string | null;
tags?: string[];
policy?: Record<string, unknown>;
};
+export type VaultFieldValuePayload = {
+ /** Canonical record name bound into the envelope (NAME for the default field). */
+ record: string;
+ blind_box?: VaultBlindBox;
+ sealed?: VaultSealedEnvelope;
+ expected_updated_at?: string;
+};
+
+export type VaultCreateFieldPayload = {
+ name: string;
+ /** Canonical record name bound into this extra field's envelope. */
+ record: string;
+ blind_box?: VaultBlindBox;
+ sealed?: VaultSealedEnvelope;
+};
+
export type TunnelQualitySnapshot = {
schema_version: 1 | 2;
state: 'healthy' | 'degraded' | 'recovering' | 'unknown';
@@ -806,7 +832,7 @@ export type ApiContextType = {
updateVibeAgent: (name: string, payload: VibeAgentUpdatePayload) => Promise<{ ok: boolean; agent: VibeAgentFull }>;
setDefaultVibeAgent: (name: string) => Promise<{ ok: boolean; default_agent_name: string; agent: VibeAgentBrief }>;
removeVibeAgent: (name: string) => Promise<{ ok: boolean; code?: string; message?: string; references?: Record<string, number>; removed_agent?: string; archived_agent?: VibeAgentBrief; default_agent_name?: string | null }>;
- listVaultSecrets: () => Promise<{ ok: boolean; secrets: VaultSecret[] }>;
+ listVaultSecrets: (opts?: { cache?: boolean }) => Promise<{ ok: boolean; secrets: VaultSecret[] }>;
getVaultVmk: () => Promise<VaultVmkResult>;
getVaultPubkey: () => Promise<{ ok: boolean; public_key: string; fingerprint: string }>;
getVaultAgentPubkey: () => Promise<{ ok: boolean; public_key: string; fingerprint: string }>;
@@ -820,7 +846,7 @@ export type ApiContextType = {
saveVaultSettings: (payload: Partial<VaultSettings>) => Promise<VaultSettingsResult>;
createVaultRevealContext: (
name: string,
- payload?: { session_label?: string },
+ payload?: { session_label?: string; field?: string },
) => Promise<VaultRevealContextResult>;
deriveSigningAddresses: (publicKey: string) => Promise<{ ok: boolean; addresses?: SigningAddresses; code?: string; message?: string }>;
createVaultAuthzWebAuthnOptions: () => Promise<VaultWebAuthnRegistrationOptions>;
@@ -829,6 +855,8 @@ export type ApiContextType = {
) => Promise<{ ok: boolean; factor?: Record<string, unknown>; code?: string; message?: string }>;
createVaultSecret: (payload: VaultCreatePayload, opts?: { handleError?: boolean }) => Promise<{ ok: boolean; secret?: VaultSecret; code?: string; message?: string }>;
updateVaultSecret: (name: string, payload: VaultMetadataUpdatePayload, opts?: { handleError?: boolean }) => Promise<{ ok: boolean; secret?: VaultSecret; code?: string; message?: string }>;
+ updateVaultSecretField: (name: string, field: string, payload: VaultFieldValuePayload, opts?: { handleError?: boolean }) => Promise<{ ok: boolean; secret?: VaultSecret; code?: string; message?: string }>;
+ deleteVaultSecretField: (name: string, field: string, payload: { expected_updated_at: string }) => Promise<{ ok: boolean; secret?: VaultSecret; code?: string; message?: string }>;
deleteVaultSecret: (name: string) => Promise<{ ok: boolean; removed?: boolean; code?: string; message?: string }>;
getVaultProvisionRequest: (
name: string,
@@ -2527,12 +2555,12 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ children
// absent page there means it vanished mid-session rather than never existed.
const readShowPageJson = (path: string) => getJson(path, { expectedCodes: ['show_page_not_found'] });
- const getCachedJson = (path: string, ttlMs = 1500, opts?: { handleError?: boolean }) => {
+ const getCachedJson = (path: string, ttlMs = 1500, opts?: { cache?: boolean; handleError?: boolean }) => {
// Best-effort callers (handleError: false) bypass the shared read cache so a
// silently-failing request can't hand its suppressed-error promise to a
// toast-enabled caller hitting the same path.
- if (opts?.handleError === false) {
- return getJson(path, opts);
+ if (opts?.cache === false || opts?.handleError === false) {
+ return getJson(path, { handleError: opts?.handleError });
}
const now = Date.now();
const cached = readCacheRef.current.get(path);
@@ -3284,7 +3312,11 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ children
// ``getJson``/``postJson``. New mutating helpers should route through
// requestJson/postJson/patchJson/deleteJson so successful mutations always
// invalidate reusable GET promises.
- const deleteJson = async (path: string, payload?: any) => {
+ const deleteJson = async (
+ path: string,
+ payload?: any,
+ opts?: { handleError?: boolean; expectedCodes?: readonly string[] },
+ ) => {
const { payloadJson } = await requestJson(path, {
method: 'DELETE',
...(payload === undefined
@@ -3293,7 +3325,7 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ children
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}),
- });
+ }, path, opts);
return payloadJson;
};
@@ -3985,7 +4017,7 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ children
setDefaultVibeAgent: (name) => postJson('/api/agents/default', { name }),
removeVibeAgent: (name) => deleteJson(`/api/agents/${encodeURIComponent(name)}`),
getVaultVmk: () => getCachedJson('/api/vault/vmk', 1500, { handleError: false }),
- listVaultSecrets: () => getCachedJson('/api/vault/secrets', 1500),
+ listVaultSecrets: (opts) => getCachedJson('/api/vault/secrets', 1500, opts),
getVaultPubkey: () => getCachedJson('/api/vault/pubkey', 1500),
getVaultAgentPubkey: () => getCachedJson('/api/vault/agent/pubkey', 1500),
getVaultSandboxRootMetadata: () => getCachedJson('/api/vault/sandbox/root-metadata', 1500, { handleError: false }),
@@ -4001,6 +4033,21 @@ export const ApiProvider: React.FC<{ children: React.ReactNode }> = ({ children
registerVaultAuthzWebAuthnFactor: (payload) => postJson('/api/vault/authz/factors/webauthn', payload),
createVaultSecret: (payload, opts) => postJson('/api/vault/secrets', payload, opts),
updateVaultSecret: (name, payload, opts) => patchJson(`/api/vault/secrets/${encodeURIComponent(name)}`, payload, opts),
+ updateVaultSecretField: async (name, field, payload, opts) => {
+ const path = `/api/vault/secrets/${encodeURIComponent(name)}/fields/${encodeURIComponent(field)}`;
+ const { payloadJson } = await requestJson(path, {
+ method: 'PUT',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify(payload),
+ }, path, opts);
+ return payloadJson;
+ },
+ deleteVaultSecretField: (name, field, payload) =>
+ deleteJson(
+ `/api/vault/secrets/${encodeURIComponent(name)}/fields/${encodeURIComponent(field)}`,
+ payload,
+ { handleError: false },
+ ),
deleteVaultSecret: (name) => deleteJson(`/api/vault/secrets/${encodeURIComponent(name)}`),
getVaultProvisionRequest: (name, opts) =>
getCachedJson(`/api/vault/provision-requests/${encodeURIComponent(name)}`, 1500, opts),
diff --git a/ui/src/context/ApiContext.vault.test.tsx b/ui/src/context/ApiContext.vault.test.tsx
new file mode 100644
index 000000000..1547ef980
--- /dev/null
+++ b/ui/src/context/ApiContext.vault.test.tsx
@@ -0,0 +1,57 @@
+/* @vitest-environment jsdom */
+import { cleanup, renderHook } from '@testing-library/react';
+import { createInstance } from 'i18next';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import zh from '@/i18n/zh.json';
+
+const apiFetch = vi.hoisted(() => vi.fn());
+const showToast = vi.hoisted(() => vi.fn());
+vi.mock('../lib/apiFetch', async (original) => ({
+ ...await original<typeof import('../lib/apiFetch')>(), apiFetch,
+}));
+vi.mock('./ToastContext', () => ({ useToast: () => ({ showToast }) }));
+vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: i18n.t.bind(i18n) }) }));
+import { ApiProvider, useApi } from './ApiContext';
+
+const i18n = createInstance();
+void i18n.init({ lng: 'zh', resources: { zh: { translation: zh } }, interpolation: { escapeValue: false } });
+beforeEach(() => {
+ apiFetch.mockReset();
+ showToast.mockReset();
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+});
+afterEach(() => { cleanup(); vi.restoreAllMocks(); });
+
+// The transport must send the version, not merely pass it to a mock API method.
+it('sends the displayed field version in the DELETE request body', async () => {
+ apiFetch.mockResolvedValue(new Response(JSON.stringify({ ok: true })));
+ const { result } = renderHook(useApi, { wrapper: ApiProvider });
+ await result.current.deleteVaultSecretField('LOGIN', 'username', { expected_updated_at: 'editor-version' });
+ const [path, request] = apiFetch.mock.calls.at(-1)!;
+ expect(path).toBe('/api/vault/secrets/LOGIN/fields/username');
+ expect(request.method).toBe('DELETE');
+ expect(request.body).toBe(JSON.stringify({ expected_updated_at: 'editor-version' }));
+});
+
+it('keeps a stale field DELETE inline instead of showing a global toast', async () => {
+ apiFetch.mockResolvedValue(new Response(JSON.stringify({
+ ok: false,
+ code: 'secret_conflict',
+ message: 'stale field version',
+ }), { status: 409 }));
+ const { result } = renderHook(useApi, { wrapper: ApiProvider });
+ await expect(result.current.deleteVaultSecretField('LOGIN', 'username', {
+ expected_updated_at: 'editor-version',
+ })).resolves.toMatchObject({ ok: false, code: 'secret_conflict' });
+ expect(showToast).not.toHaveBeenCalled();
+});
+
+it.each([
+ 'invalid_field_name', 'field_exists', 'field_not_found', 'too_many_fields',
+ 'fields_not_supported', 'record_mismatch', 'secret_conflict', 'fields_corrupt',
+] as const)('localizes the Web toast for %s instead of displaying the service English', async (code) => {
+ apiFetch.mockResolvedValue(new Response(JSON.stringify({ code, message: 'English service detail' }), { status: 409 }));
+ const { result } = renderHook(useApi, { wrapper: ApiProvider });
+ await expect(result.current.createVaultSecret({ name: 'LOGIN' })).rejects.toMatchObject({ code, message: zh.errors[code] });
+ expect(showToast).toHaveBeenCalledWith(zh.errors[code], 'error');
+});
diff --git a/ui/src/i18n/en.json b/ui/src/i18n/en.json
index 4f7462469..a979594f3 100644
--- a/ui/src/i18n/en.json
+++ b/ui/src/i18n/en.json
@@ -2520,6 +2520,15 @@
"retry": "Retry"
},
"errors": {
+ "invalid_field_name": "Use 1–64 lowercase letters, digits or underscores for field names, starting with a letter.",
+ "field_exists": "A field with this name already exists. Choose a different name.",
+ "field_not_found": "This field no longer exists. Refresh the secret and choose one of its current fields.",
+ "too_many_fields": "A secret can have at most 32 fields, including the default field.",
+ "fields_corrupt": "This secret's stored field data is damaged. The default value remains available; field changes are disabled to preserve existing data.",
+ "fields_not_supported": "Signing keys do not support named fields or default-field renaming.",
+ "record_mismatch": "This field changed while you were saving. Refresh the secret and try again.",
+ "secret_conflict": "This secret changed elsewhere. Review the refreshed fields and try again; your change was not saved.",
+ "secret_not_found": "This secret no longer exists. Refresh the vault and choose another secret.",
"retry_not_available": "This notice cannot be retried. Send a message to continue.",
"retry_stale": "Newer work has already started. Send a message if you want to continue.",
"retry_busy": "The previous turn is still settling. Try again after it stops.",
@@ -4974,18 +4983,45 @@
"copy": "Copy value",
"showInBrowser": "Show in browser",
"errors": {
+ "staleField": "This link points to a field that no longer exists. Open the secret and choose a current field.",
"contextFailed": "Couldn't prepare the reveal. Please try again.",
"unavailable": "Reveal isn't available for this secret yet."
}
},
"saved": "Updated {{name}}",
- "editSecret": "Edit info",
+ "editSecret": "Edit secret",
"rowActions": "More actions",
"edit": {
- "title": "Edit info",
- "subtitle": "Info edits keep grants; fetch policy changes require new approval",
+ "title": "Edit secret",
+ "subtitle": "Value or fetch policy changes require new approval",
"lockedHint": "Name, kind and protection can't be changed"
},
+ "fields": {
+ "title": "Fields",
+ "name": "Field {{index}} name",
+ "namePlaceholder": "field_name",
+ "value": "Value for {{field}}",
+ "default": "Default",
+ "defaultName": "Default field name",
+ "newName": "New field name",
+ "newValue": "New field value",
+ "add": "Add field",
+ "loginTemplate": "Login template",
+ "remove": "Remove {{field}}",
+ "removeConfirm": "Remove this field and its value? Existing grants will expire.",
+ "rename": "Rename",
+ "save": "Save field",
+ "saveNamed": "Save {{field}}",
+ "saved": "Field saved",
+ "draftsDropped": "Drafts for fields removed elsewhere were dropped: {{fields}}.",
+ "recordConflict": "This field changed while you were saving. The value was not written; reload the secret and try again.",
+ "secretConflict": "This secret changed while you were saving. Its fields are now refreshed; review them and save again. Your value was not written.",
+ "replacePlaceholder": "Enter a replacement value",
+ "revealField": "Field to reveal",
+ "namesHelp": "Use lowercase letters, digits and underscores; start with a letter. Each field needs a unique name and a value.",
+ "singleFile": "File upload supports one value. Switch to Text before adding fields.",
+ "editHelp": "Changes save immediately. Adding, replacing or removing values expires grants; renaming the default field does not. Leave a value blank to keep it. Extra field names cannot be changed."
+ },
"protectedUnlock": {
"checking": "Checking your protected vault…",
"unlocked": "Protected vault unlocked for this session",
diff --git a/ui/src/i18n/zh.json b/ui/src/i18n/zh.json
index 0be7dc05e..8e6ccaade 100644
--- a/ui/src/i18n/zh.json
+++ b/ui/src/i18n/zh.json
@@ -2520,6 +2520,15 @@
"retry": "重试"
},
"errors": {
+ "invalid_field_name": "字段名须为 1–64 个小写字母、数字或下划线,且以字母开头。",
+ "field_exists": "此字段名已存在,请使用其他名称。",
+ "field_not_found": "此字段已不存在。请刷新密钥并选择当前字段。",
+ "too_many_fields": "每个密钥最多可包含 32 个字段(含默认字段)。",
+ "fields_corrupt": "此密钥保存的字段数据已损坏。默认值仍可使用;为保留现有数据,字段修改已禁用。",
+ "fields_not_supported": "签名密钥不支持命名字段或默认字段改名。",
+ "record_mismatch": "保存期间字段记录发生变化,请刷新密钥后重试。",
+ "secret_conflict": "此密钥已在其他位置修改。请检查刷新后的字段再试;你的修改尚未保存。",
+ "secret_not_found": "此密钥已不存在。请刷新密钥库并选择其他密钥。",
"retry_not_available": "这条通知无法重试,可以发送消息继续。",
"retry_stale": "会话已经开始了后续任务,如需继续请发送消息。",
"retry_busy": "上一轮还在结束处理中,请稍后再试。",
@@ -4974,18 +4983,45 @@
"copy": "复制值",
"showInBrowser": "在浏览器中查看",
"errors": {
+ "staleField": "此链接指向的字段已不存在。请打开密钥并选择当前字段。",
"contextFailed": "无法准备查看,请重试。",
"unavailable": "此保护档暂不支持查看。"
}
},
"saved": "已更新 {{name}}",
- "editSecret": "编辑信息",
+ "editSecret": "编辑 Secret",
"rowActions": "更多操作",
"edit": {
- "title": "编辑信息",
- "subtitle": "普通信息不影响授权;Fetch 策略变化会重新审批",
+ "title": "编辑 Secret",
+ "subtitle": "值或 Fetch 策略变化后需要重新审批",
"lockedHint": "名称、类型、保护级别不可修改"
},
+ "fields": {
+ "title": "字段",
+ "name": "字段 {{index}} 名称",
+ "namePlaceholder": "field_name",
+ "value": "{{field}} 的值",
+ "default": "默认",
+ "defaultName": "默认字段名称",
+ "newName": "新字段名称",
+ "newValue": "新字段值",
+ "add": "添加字段",
+ "loginTemplate": "登录模板",
+ "remove": "移除 {{field}}",
+ "removeConfirm": "移除此字段及其值?已有授权将失效。",
+ "rename": "改名",
+ "save": "保存字段",
+ "saveNamed": "保存 {{field}}",
+ "saved": "字段已保存",
+ "draftsDropped": "其他位置已移除字段,已丢弃这些草稿:{{fields}}。",
+ "recordConflict": "保存期间字段记录发生变化。值未写入,请重新加载 Secret 后再试。",
+ "secretConflict": "保存期间此密钥发生变化,字段已刷新。请检查后重新保存;你的值尚未写入。",
+ "replacePlaceholder": "输入替换值",
+ "revealField": "要显示的字段",
+ "namesHelp": "使用小写字母、数字和下划线,以字母开头。每个字段的名称必须唯一且必须填写值。",
+ "singleFile": "文件上传仅支持单值。添加字段前请先切换到文本模式。",
+ "editHelp": "修改立即保存。添加、替换或移除值会使授权失效;默认字段改名不会。值留空则保留原值。额外字段不能改名。"
+ },
"protectedUnlock": {
"checking": "正在检查你的保护层…",
"unlocked": "保护层已在本会话解锁",
diff --git a/ui/src/lib/__fixtures__/p2_core_crypto.json b/ui/src/lib/__fixtures__/p2_core_crypto.json
index 2dc6f23f5..cfaa1682f 100644
--- a/ui/src/lib/__fixtures__/p2_core_crypto.json
+++ b/ui/src/lib/__fixtures__/p2_core_crypto.json
@@ -75,6 +75,35 @@
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
"000000000000012c"
]
+ },
+ {
+ "purpose": "seal",
+ "name": "GITHUB_LOGIN.username",
+ "grant_id": "",
+ "sign_scheme": "",
+ "digest_hex": "",
+ "approval_nonce_hex": "",
+ "approval_expires_at_unix": null,
+ "operation_hash_hex": "",
+ "aad_hex": "617661756c743a626c696e642d626f783a6161643a7631000000047365616c000000154749544855425f4c4f47494e2e757365726e616d65000000116d616368696e652d61657367636d2d7631000000010100000000000000000000000000000000000000000000000000000000"
+ },
+ {
+ "purpose": "agent-deliver",
+ "name": "GITHUB_LOGIN.username",
+ "grant_id": "gr_123",
+ "sign_scheme": "",
+ "digest_hex": "",
+ "approval_nonce_hex": "0102030405060708090a0b0c0d0e0f10",
+ "approval_expires_at_unix": 4102444800,
+ "operation_hash_hex": "e4137f5335871dbb195eb2a7abb16ec57c7f18784c9f10792ae5a2e6e6d1582f",
+ "aad_hex": "617661756c743a626c696e642d626f783a6161643a76310000000d6167656e742d64656c69766572000000154749544855425f4c4f47494e2e757365726e616d65000000116d616368696e652d61657367636d2d763100000001010000000667725f313233000000000000000000000000000000100102030405060708090a0b0c0d0e0f100000000800000000f486570000000020e4137f5335871dbb195eb2a7abb16ec57c7f18784c9f10792ae5a2e6e6d1582f",
+ "ttl_secs": 300,
+ "operation_hash_kind": "agent-deliver",
+ "operation_hash_fields_hex": [
+ "6167656e742d64656c69766572",
+ "4749544855425f4c4f47494e2e757365726e616d65",
+ "000000000000012c"
+ ]
}
],
"approval_nonce_hex": "0102030405060708090a0b0c0d0e0f10",
diff --git a/ui/src/lib/useProtectedVault.ts b/ui/src/lib/useProtectedVault.ts
index 90751975a..dc740a5d8 100644
--- a/ui/src/lib/useProtectedVault.ts
+++ b/ui/src/lib/useProtectedVault.ts
@@ -24,6 +24,7 @@ import { invalidateVaultSandboxPolicy } from './vaultSandboxPolicy';
*/
export type ProtectedUnlockMaterial = {
name: string;
+ field?: string;
kind?: string | null;
envelope: ProtectedRecordEnvelope;
};
diff --git a/ui/src/lib/vaultBrowserHandoff.test.tsx b/ui/src/lib/vaultBrowserHandoff.test.tsx
index d0039ed24..df50feac5 100644
--- a/ui/src/lib/vaultBrowserHandoff.test.tsx
+++ b/ui/src/lib/vaultBrowserHandoff.test.tsx
@@ -1,7 +1,7 @@
// @vitest-environment jsdom
import { createInstance } from 'i18next';
-import { cleanup, render, screen, within } from '@testing-library/react';
+import { cleanup, fireEvent, render, screen, within } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import type { ReactElement } from 'react';
import { I18nextProvider, initReactI18next } from 'react-i18next';
@@ -226,6 +226,16 @@ const cases: Array<{
expect(await screen.findByRole('menuitem', { name: /^show value$/i })).toBeTruthy();
},
},
+ {
+ surface: 'protected field edit',
+ desktop: () => <VaultSecretForm editSecret={protectedSecret} onCancel={vi.fn()} onCreated={vi.fn()} />,
+ clicks: [openInBrowser],
+ secrets: [protectedSecret],
+ vaultStatus: 'locked',
+ resumed: async () => {
+ expect(within(await resumedDialog()).getByLabelText('Value for value')).toBeTruthy();
+ },
+ },
];
const ceremonies = [vault.setupPasskey, vault.unlockPasskey, vault.approveProtectedRelease, vault.signProtectedRequest, vault.revealProtectedValue];
@@ -263,6 +273,29 @@ afterEach(() => {
// on the request's Standard default, a reveal on a bare list, an agent's name dropped from Add),
// strands the user in the browser; only a round trip through both ends catches that.
describe('desktop shell protected-vault browser handoff', () => {
+ // Field labels must survive the same round trip as the secret name; reopening just the
+ // secret silently changes an extra-field reveal into a default-field reveal.
+ it('resumes the selected extra field in the browser without revealing anything automatically', async () => {
+ const user = userEvent.setup();
+ api.getVaultRequests.mockResolvedValue({ requests: [] });
+ api.listVaultSecrets.mockResolvedValue({
+ secrets: [{ ...protectedSecret, default_field: 'password', fields: ['password', 'username'] }],
+ });
+ const open = vi.spyOn(window, 'open').mockReturnValue(null);
+ Object.defineProperty(window, '__AVIBE_DESKTOP_SHELL__', { configurable: true, value: true });
+ renderAt('/vaults', <VaultsPage />);
+ await user.click(await screen.findByRole('button', { name: /^more actions$/i }));
+ fireEvent.change(screen.getByRole('combobox', { name: 'Field to reveal' }), { target: { value: 'username' } });
+ await user.click(screen.getByRole('menuitem', { name: /^show in browser$/i }));
+ const target = new URL(String(open.mock.calls[0][0]));
+ expect(target.searchParams.get('field')).toBe('username');
+ cleanup();
+ delete (window as { __AVIBE_DESKTOP_SHELL__?: true }).__AVIBE_DESKTOP_SHELL__;
+ renderAt(`${target.pathname}${target.search}`, <VaultsPage />);
+ expect((await screen.findByRole('combobox', { name: 'Field to reveal' }) as HTMLSelectElement).value).toBe('username');
+ expect(vault.revealProtectedValue).not.toHaveBeenCalled();
+ });
+
it.each(cases)('$surface resumes in the browser without starting a passkey step', async (c) => {
const user = userEvent.setup();
vault.status = c.vaultStatus ?? 'needs-setup';
diff --git a/ui/src/lib/vaultBrowserHandoff.ts b/ui/src/lib/vaultBrowserHandoff.ts
index f1e3b20c3..d1f3ba606 100644
--- a/ui/src/lib/vaultBrowserHandoff.ts
+++ b/ui/src/lib/vaultBrowserHandoff.ts
@@ -24,11 +24,13 @@ export type VaultBrowserStep =
| { kind: 'request'; requestId: string; startProtected?: boolean }
/** Add a new protected secret, fixed to `name` when an agent asked for it by name. */
| { kind: 'add'; name?: string }
+ /** Replace fields of an existing protected secret. */
+ | { kind: 'edit'; secretName: string }
/** Show a protected secret's value. */
- | { kind: 'reveal'; secretName: string };
+ | { kind: 'reveal'; secretName: string; field?: string };
// `request_id` is also the deep link Avibe sends to IM (`vault_request_url`).
-const STEP_PARAMS = ['request_id', 'protection', 'add', 'name', 'reveal'];
+const STEP_PARAMS = ['request_id', 'protection', 'add', 'name', 'edit', 'reveal', 'field'];
/** Opens Vaults in the user's browser on `step`. */
export function openVaultsInBrowser(step: VaultBrowserStep): void {
@@ -38,7 +40,9 @@ export function openVaultsInBrowser(step: VaultBrowserStep): void {
? { request_id: step.requestId, ...(step.startProtected ? { protection: 'protected' } : {}) }
: step.kind === 'add'
? { add: 'protected', ...(step.name ? { name: step.name } : {}) }
- : { reveal: step.secretName };
+ : step.kind === 'edit'
+ ? { edit: step.secretName }
+ : { reveal: step.secretName, ...(step.field ? { field: step.field } : {}) };
for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
openLinkInNewContext(url.toString());
}
@@ -48,8 +52,11 @@ export function readVaultBrowserStep(params: URLSearchParams): VaultBrowserStep
const requestId = params.get('request_id')?.trim();
if (requestId) return { kind: 'request', requestId, startProtected: params.get('protection') === 'protected' };
if (params.get('add') === 'protected') return { kind: 'add', name: params.get('name')?.trim() || undefined };
+ const editName = params.get('edit')?.trim();
+ if (editName) return { kind: 'edit', secretName: editName };
const secretName = params.get('reveal')?.trim();
- return secretName ? { kind: 'reveal', secretName } : null;
+ const field = params.get('field')?.trim();
+ return secretName ? { kind: 'reveal', secretName, ...(field ? { field } : {}) } : null;
}
/** `params` without a step, so a step resumed once doesn't resume again on reload. */
diff --git a/ui/src/lib/vaultCrypto.test.ts b/ui/src/lib/vaultCrypto.test.ts
index fa4c81321..44caa6893 100644
--- a/ui/src/lib/vaultCrypto.test.ts
+++ b/ui/src/lib/vaultCrypto.test.ts
@@ -32,6 +32,7 @@ import {
packProtectedRecord,
unpackProtectedRecord,
signDigest,
+ signProtectedDigest,
SIGN_SCHEME_ECDSA_SECP256K1_DER,
SIGN_SCHEME_ECDSA_SECP256K1_RECOVERABLE,
SIGN_SCHEME_SCHNORR_SECP256K1_BIP340,
@@ -214,6 +215,35 @@ describe('vaultCrypto signing vectors', () => {
});
describe('vaultCrypto blind boxes', () => {
+ // Shared positive vectors permit field names for seal/deliver; pin the boundary so widening
+ // that grammar cannot silently allow fields on signing keys or nested/invalid field names.
+ it.each(['LOGIN.Password', 'LOGIN.1password', 'LOGIN.user.name', `LOGIN.${'x'.repeat(65)}`, '.password'])(
+ 'rejects malformed field record %s', (name) => {
+ expect(() => standardCreateBlindBoxContext(name)).toThrow('record name');
+ },
+ );
+
+ it('rejects field records for signing even though they are valid seal records', async () => {
+ const vector = p2.blind_box_aad_examples.cases.find((example) => example.purpose === 'agent-sign')!;
+ await expect(protectedDekReleaseBlindBoxContext('KEY.password', {
+ kind: 'agent-sign', grantId: vector.grant_id, signatureScheme: vector.sign_scheme as SignatureScheme,
+ digest: vector.digest_hex, ttlSecs: vector.ttl_secs!, approval: approvalFromVector(vector),
+ operationHash: vector.operation_hash_hex,
+ })).rejects.toThrow('secret name');
+ expect(() => blindBoxAad({
+ purpose: 'agent-sign', name: 'KEY.password', grantId: vector.grant_id,
+ signScheme: vector.sign_scheme as SignatureScheme, digest: bytesFromHex(vector.digest_hex),
+ ttlSecs: vector.ttl_secs!, approvalNonce: bytesFromHex(vector.approval_nonce_hex),
+ approvalExpiresAtUnix: vector.approval_expires_at_unix!, operationHash: bytesFromHex(vector.operation_hash_hex),
+ })).toThrow('secret name');
+ const vmk = newVmk();
+ const key = importSigningKey('01'.padStart(64, '0'));
+ const sealed = await sealProtected(key.privateKey, vmk, { name: 'KEY.password' });
+ await expect(signProtectedDigest(
+ sealed, vmk, { name: 'KEY.password' }, vector.digest_hex, vector.sign_scheme as SignatureScheme,
+ )).rejects.toThrow('secret name');
+ });
+
it('matches all shared avault blind-box AAD examples byte-for-byte', async () => {
expect(p2.blind_box.aad_domain_utf8).toBe(BLIND_BOX_AAD_DOMAIN);
expect(p2.blind_box_aad_examples.wrap_scheme).toBe(WRAP_SCHEME);
diff --git a/ui/src/lib/vaultCrypto.ts b/ui/src/lib/vaultCrypto.ts
index b72036081..680d9a892 100644
--- a/ui/src/lib/vaultCrypto.ts
+++ b/ui/src/lib/vaultCrypto.ts
@@ -17,6 +17,7 @@ const NONCE_BYTES = 12;
const PASSKEY_PRF_SALT_BYTES = 32;
const PASSKEY_HKDF_INFO = 'avault:protected-vmk:kek-passkey:v1';
const SECRET_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RECORD_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*(\.[a-z][a-z0-9_]{0,63})?$/;
const textEncoder = new TextEncoder();
@@ -460,7 +461,7 @@ export function passkeyPrfSaltEntries(wrapMeta: string | WrapMeta): PasskeyPrfSa
}
function protectedRecordAad(context: ProtectedRecordContext): Uint8Array {
- const name = utf8(validateSecretName(context.name));
+ const name = utf8(validateRecordName(context.name));
const scheme = utf8(context.scheme ?? WRAP_SCHEME);
const out = new Uint8Array(name.length + scheme.length + 1);
out.set(name, 0);
@@ -492,7 +493,7 @@ async function requireValidPinnedPublicKey(publicKey: AvaultPublicKey): Promise<
}
function assertReleaseMatchesRecord(recordContext: ProtectedRecordContext, context: ProtectedDekReleaseBlindBoxContext): void {
- if (validateSecretName(recordContext.name) !== validateSecretName(context.name)) {
+ if (validateRecordName(recordContext.name) !== validateRecordName(context.name)) {
throw new Error('protected DEK release context name does not match record name');
}
}
@@ -708,6 +709,13 @@ function validateSecretName(name: string): string {
return name;
}
+function validateRecordName(name: string): string {
+ if (typeof name !== 'string' || !RECORD_NAME_PATTERN.test(name)) {
+ throw new Error('vault secret name / record name must be NAME or NAME.field');
+ }
+ return name;
+}
+
function validateNonEmpty(value: string, field: string): string {
if (typeof value !== 'string' || value.trim() === '') {
throw new Error(`${field} is required`);
@@ -779,7 +787,7 @@ function normalizeBlindBoxContext(context: BlindBoxContext): BlindBoxContext {
});
return {
purpose: 'agent-deliver',
- name: validateSecretName(context.name),
+ name: validateRecordName(context.name),
grantId: validateNonEmpty(context.grantId, 'grant id'),
ttlSecs: normalizeU64(context.ttlSecs, 'ttl seconds'),
approvalNonce: approval.approvalNonce,
@@ -812,7 +820,7 @@ function normalizeBlindBoxContext(context: BlindBoxContext): BlindBoxContext {
export function standardCreateBlindBoxContext(name: string): StandardCreateBlindBoxContext {
return {
purpose: 'seal',
- name: validateSecretName(name),
+ name: validateRecordName(name),
};
}
@@ -840,7 +848,7 @@ export async function protectedDekReleaseBlindBoxContext(
name: string,
operation: ProtectedDekReleaseOperation,
): Promise<ProtectedDekReleaseBlindBoxContext> {
- const normalizedName = validateSecretName(name);
+ const normalizedName = operation.kind === 'agent-sign' ? validateSecretName(name) : validateRecordName(name);
const approval = normalizeApproval(operation.approval);
switch (operation.kind) {
@@ -901,7 +909,7 @@ export async function blindBoxAgentDeliverOperationHash(
): Promise<Uint8Array> {
return blindBoxOperationHash([
'agent-deliver',
- validateSecretName(name),
+ validateRecordName(name),
u64Be(ttlSecs, 'ttl seconds'),
]);
}
@@ -1014,6 +1022,7 @@ export async function signProtectedDigest(
scheme: SignatureScheme,
options: SignDigestOptions = {},
): Promise<SignatureResult> {
+ validateSecretName(context.name);
const privateKey = await openProtected(sealedKey, vmk, context);
try {
return signDigest(privateKey, digest, scheme, options);
diff --git a/ui/src/lib/vaultErrors.ts b/ui/src/lib/vaultErrors.ts
new file mode 100644
index 000000000..fd6e861e8
--- /dev/null
+++ b/ui/src/lib/vaultErrors.ts
@@ -0,0 +1,9 @@
+import type { TFunction } from 'i18next';
+import { errorMessage } from './errorMessage';
+
+/** Use the same stable-code catalog as ApiContext's toast fallback. */
+export function vaultErrorMessage(t: TFunction, error: unknown, fallback: string): string {
+ const message = errorMessage(error) ?? fallback;
+ const code = typeof error === 'object' && error !== null && 'code' in error ? error.code : null;
+ return typeof code === 'string' && code ? t(`errors.${code}`, { defaultValue: message }) : message;
+}
diff --git a/ui/src/lib/vaultFields.test.ts b/ui/src/lib/vaultFields.test.ts
new file mode 100644
index 000000000..828717bb8
--- /dev/null
+++ b/ui/src/lib/vaultFields.test.ts
@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { vaultHasNamedFieldShape } from './vaultFields';
+
+describe('vaultHasNamedFieldShape', () => {
+ it.each([
+ [{ kind: 'static', default_field: 'value', fields: ['value'] }, false],
+ [{ kind: 'static', default_field: 'password', fields: ['password'] }, true],
+ [{ kind: 'static', default_field: 'password', fields: ['password', 'username'] }, true],
+ [{ kind: 'static', default_field: 'value', fields: ['value'], fields_state: 'corrupt' }, true],
+ [{ kind: 'keypair', default_field: 'value', fields: ['value'] }, false],
+ ] as const)('classifies %o as %s', (secret, expected) => {
+ expect(vaultHasNamedFieldShape(secret)).toBe(expected);
+ });
+});
diff --git a/ui/src/lib/vaultFields.ts b/ui/src/lib/vaultFields.ts
new file mode 100644
index 000000000..a22615148
--- /dev/null
+++ b/ui/src/lib/vaultFields.ts
@@ -0,0 +1,34 @@
+import type { VaultSecret } from '@/context/ApiContext';
+
+export const VAULT_FIELD_PATTERN = /^[a-z][a-z0-9_]{0,63}$/;
+export const MAX_VAULT_FIELDS = 32;
+
+export function vaultDefaultField(secret: Pick<VaultSecret, 'default_field'>): string {
+ return secret.default_field && VAULT_FIELD_PATTERN.test(secret.default_field) ? secret.default_field : 'value';
+}
+
+export function vaultFieldNames(secret: Pick<VaultSecret, 'default_field' | 'fields'>): string[] {
+ const defaultField = vaultDefaultField(secret);
+ return [defaultField, ...(secret.fields ?? []).filter((field) => field !== defaultField)];
+}
+
+export function vaultFieldFingerprint(secret: Pick<VaultSecret, 'default_field' | 'fields' | 'fields_state' | 'updated_at'>): string {
+ // Default labels are metadata-only and can change without an envelope version.
+ return JSON.stringify([vaultDefaultField(secret), vaultFieldNames(secret), secret.fields_state ?? null, secret.updated_at]);
+}
+
+type VaultFieldShape = Pick<VaultSecret, 'default_field' | 'fields' | 'fields_state'> &
+ Partial<Pick<VaultSecret, 'kind'>>;
+
+export function vaultHasNamedFieldShape(secret: VaultFieldShape): boolean {
+ if (secret.kind === 'keypair') return false;
+ const fields = vaultFieldNames(secret);
+ return secret.fields_state === 'corrupt'
+ || secret.default_field !== 'value'
+ || fields.length !== 1
+ || fields[0] !== 'value';
+}
+
+export function vaultRecordName(name: string, field: string, defaultField: string): string {
+ return field === defaultField ? name : `${name}.${field}`;
+}
diff --git a/vibe/api.py b/vibe/api.py
index 846ab80b0..8f9c06a96 100644
--- a/vibe/api.py
+++ b/vibe/api.py
@@ -2373,6 +2373,168 @@ def _vault_api_error_from_avault(exc: "AvaultError", *, prefix: str) -> VaultApi
return VaultApiError(f"{prefix}: {message}", code="avault_failed")
+_VAULT_MAX_FIELDS = 32
+
+
+def _vault_validate_field_name(value: Any, *, field: str = "field") -> str:
+ from storage import vault_service
+
+ return vault_service.validate_field_name(value, field=field)
+
+
+def _vault_secret_record_names(meta: dict[str, Any]) -> list[str]:
+ """Expand one value-free secret meta into its encrypted record names."""
+
+ from storage import vault_service
+
+ return [str(name) for name in vault_service.secret_record_names(meta)]
+
+
+def _vault_record_meta(
+ conn: Any,
+ ref: str,
+ *,
+ user_context: Any = None,
+) -> dict[str, Any]:
+ """Resolve a record ref through the storage public contract."""
+
+ from storage import vault_service
+
+ return dict(vault_service.get_secret_record_meta(conn, ref, user_context=user_context))
+
+
+def _vault_secret_management_meta(
+ conn: Any,
+ secret_name: str,
+ *,
+ user_context: Any = None,
+) -> dict[str, Any]:
+ """Authorize management before a field is sealed, then return masked meta."""
+
+ from storage import vault_service
+
+ vault_service.require_secret_management(conn, secret_name, user_context=user_context)
+ return dict(vault_service.get_secret_meta(conn, secret_name, user_context=user_context))
+
+
+# Stable Web field errors: ApiContext/vaultErrorMessage resolve errors.<code>.
+# The catalog contract test also probes all service exception mappings so adding
+# a mapped code without declaring and translating it fails validation.
+_VAULT_FIELD_ERROR_CODES = (
+ "invalid_field_name",
+ "field_exists",
+ "field_not_found",
+ "too_many_fields",
+ "fields_corrupt",
+ "fields_not_supported",
+ "record_mismatch",
+ "secret_conflict",
+)
+
+
+def _vault_field_service_error(exc: Exception) -> VaultApiError:
+ from storage import vault_service
+
+ mappings: tuple[tuple[type[Exception], str, int], ...] = (
+ (vault_service.InvalidFieldNameError, "invalid_field_name", 400),
+ (vault_service.FieldExistsError, "field_exists", 409),
+ (vault_service.FieldNotFoundError, "field_not_found", 404),
+ (vault_service.TooManyFieldsError, "too_many_fields", 409),
+ (vault_service.FieldsCorruptError, "fields_corrupt", 409),
+ (vault_service.FieldsNotSupportedError, "fields_not_supported", 409),
+ (vault_service.RecordMismatchError, "record_mismatch", 409),
+ (vault_service.SecretConflictError, "secret_conflict", 409),
+ )
+ for error_type, code, status in mappings:
+ if isinstance(exc, error_type):
+ return VaultApiError(str(exc), code=code, status=status)
+ if isinstance(exc, vault_service.InvalidRequestError):
+ return VaultApiError(str(exc), code="invalid_request", status=409)
+ if isinstance(exc, vault_service.SecretNotFoundError):
+ return VaultApiError(str(exc), code="secret_not_found", status=404)
+ if isinstance(exc, vault_service.VaultSecretAccessError):
+ return _vault_secret_access_forbidden(exc)
+ return VaultApiError(str(exc), code="vault_error")
+
+
+def _vault_create_field_specs(
+ payload: dict[str, Any],
+ *,
+ secret_name: str,
+ kind: str,
+ default_field: str,
+) -> list[dict[str, Any]]:
+ from storage import vault_service
+
+ if "fields" not in payload:
+ return []
+ raw_fields = payload.get("fields")
+ if not isinstance(raw_fields, list):
+ raise VaultApiError("fields must be an array", code="invalid_request", status=409)
+ if kind == "keypair" and "fields" in payload:
+ raise VaultApiError(
+ "keypair secrets do not support fields",
+ code="fields_not_supported",
+ status=409,
+ )
+ if len(raw_fields) + 1 > _VAULT_MAX_FIELDS:
+ raise VaultApiError(
+ f"a vault secret can have at most {_VAULT_MAX_FIELDS} fields",
+ code="too_many_fields",
+ status=409,
+ )
+ names: set[str] = {default_field}
+ specs: list[dict[str, Any]] = []
+ envelope_key = "blind_box" if str(payload.get("protection") or "standard").strip().lower() == "standard" else "sealed"
+ for index, item in enumerate(raw_fields):
+ if not isinstance(item, dict):
+ raise VaultApiError(
+ f"fields[{index}] must be an object",
+ code="invalid_request",
+ status=409,
+ )
+ try:
+ field_name = _vault_validate_field_name(item.get("name"), field=f"fields[{index}].name")
+ except vault_service.InvalidFieldNameError as exc:
+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exc
+ if field_name in names:
+ raise VaultApiError(
+ f"field {field_name!r} already exists",
+ code="field_exists",
+ status=409,
+ )
+ if "record" not in item:
+ raise VaultApiError(
+ f"fields[{index}].record is required",
+ code="invalid_request",
+ status=409,
+ )
+ record = item["record"]
+ if not isinstance(record, str):
+ raise VaultApiError(
+ f"fields[{index}].record must be a string",
+ code="record_mismatch",
+ status=409,
+ )
+ expected_record = f"{secret_name}.{field_name}"
+ if record != expected_record:
+ raise VaultApiError(
+ f"fields[{index}].record must be {expected_record!r}",
+ code="record_mismatch",
+ status=409,
+ )
+ envelope = item.get(envelope_key)
+ if not isinstance(envelope, dict):
+ raise VaultApiError(
+ f"fields[{index}].{envelope_key} is required",
+ code="invalid_envelope" if envelope_key == "sealed" else "blind_box_required",
+ status=400,
+ )
+ names.add(field_name)
+ specs.append({"name": field_name, "record": record, envelope_key: envelope})
+ return specs
+
+
def _vault_engine():
from storage.db import create_sqlite_engine
from storage.importer import ensure_sqlite_state, resolve_primary_platform_from_config
@@ -2830,7 +2992,11 @@ def create_vault_agent_bindings_batch(payload: dict) -> dict:
ttl_seconds = int(duration["ttl_seconds"])
expires_at = now + timedelta(seconds=ttl_seconds)
expires_at_unix = int(expires_at.timestamp())
- display = _operation_context_display(request_payload, grantable_members, grant_ttl_seconds=ttl_seconds)
+ display_members: list[dict[str, Any]] = []
+ for meta in grantable_members:
+ for record_name in _vault_secret_record_names(meta):
+ display_members.append({**meta, "name": record_name})
+ display = _operation_context_display(request_payload, display_members, grant_ttl_seconds=ttl_seconds)
agent = {
"publicKey": {
"public_key": str(agent_pubkey["public_key"]),
@@ -2841,45 +3007,45 @@ def create_vault_agent_bindings_batch(payload: dict) -> dict:
items: list[dict[str, Any]] = []
issued_items: list[dict[str, Any]] = []
for meta in protected_metas:
- name = str(meta["name"])
- approval_nonce = os.urandom(16)
- context_request_id = f"vab_{uuid.uuid4().hex}"
- release = {
- "name": name,
- "ttlSecs": ttl_seconds,
- "approvalNonce": list(approval_nonce),
- "approvalExpiresAtUnix": expires_at_unix,
- "operationHash": _agent_deliver_operation_hash(name, ttl_seconds),
- }
- context = {
- "v": 2,
- "purpose": "agent-deliver",
- "requestId": context_request_id,
- "grantId": option["grant_id"],
- "display": display,
- "release": release,
- "agent": agent,
- "expiresAt": _isoformat_z(expires_at),
- }
- signed_context = _signed_operation_context(context, key)
- approval = {
- "nonce": _b64(approval_nonce),
- "expires_at_unix": expires_at_unix,
- }
- items.append(
- {
+ for name in _vault_secret_record_names(meta):
+ approval_nonce = os.urandom(16)
+ context_request_id = f"vab_{uuid.uuid4().hex}"
+ release = {
"name": name,
- "context": signed_context,
- "approval": approval,
+ "ttlSecs": ttl_seconds,
+ "approvalNonce": list(approval_nonce),
+ "approvalExpiresAtUnix": expires_at_unix,
+ "operationHash": _agent_deliver_operation_hash(name, ttl_seconds),
}
- )
- issued_items.append(
- {
- "name": name,
- "request_id": context_request_id,
- "approval": approval,
+ context = {
+ "v": 2,
+ "purpose": "agent-deliver",
+ "requestId": context_request_id,
+ "grantId": option["grant_id"],
+ "display": display,
+ "release": release,
+ "agent": agent,
+ "expiresAt": _isoformat_z(expires_at),
}
- )
+ signed_context = _signed_operation_context(context, key)
+ approval = {
+ "nonce": _b64(approval_nonce),
+ "expires_at_unix": expires_at_unix,
+ }
+ items.append(
+ {
+ "name": name,
+ "context": signed_context,
+ "approval": approval,
+ }
+ )
+ issued_items.append(
+ {
+ "name": name,
+ "request_id": context_request_id,
+ "approval": approval,
+ }
+ )
with engine.begin() as conn:
vault_service.record_request_agent_binding_approvals(
conn,
@@ -2919,11 +3085,19 @@ def create_vault_agent_binding(payload: dict) -> dict:
raise VaultApiError("payload must be an object", code="invalid_payload")
request_id = str(payload.get("request_id") or payload.get("requestId") or "").strip()
grant_id = str(payload.get("grant_id") or payload.get("grantId") or "").strip()
- name = str(payload.get("name") or "").strip()
+ raw_name = payload.get("name")
+ requested_name = raw_name if isinstance(raw_name, str) else ""
+ if "." not in requested_name:
+ requested_name = requested_name.strip()
if not request_id or not grant_id:
raise VaultApiError("request_id and grant_id are required", code="invalid_request", status=409)
- if not vault_crypto.is_valid_secret_name(name):
+ if not requested_name or not vault_crypto.is_valid_secret_name(requested_name.split(".", 1)[0]):
raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")
+ if "." in requested_name:
+ try:
+ _vault_validate_field_name(requested_name.split(".", 1)[1], field="field")
+ except vault_service.InvalidFieldNameError as exc:
+ raise _vault_field_service_error(exc) from exc
engine = _vault_engine()
try:
@@ -2931,7 +3105,8 @@ def create_vault_agent_binding(payload: dict) -> dict:
option = _grant_option_from_request(conn, request_id)
if grant_id != option["grant_id"]:
raise vault_service.InvalidRequestError("grant id does not match the approval request")
- if name not in set(option["member_names"]):
+ base_name = requested_name.split(".", 1)[0]
+ if base_name not in set(option["member_names"]):
raise vault_service.InvalidRequestError("secret is not part of the approval request")
grant_duration_value = _grant_duration_value_from_payload(payload)
remember_duration = grant_duration_value is not None
@@ -2939,14 +3114,20 @@ def create_vault_agent_binding(payload: dict) -> dict:
grant_duration_value,
default=option.get("default_grant_duration") or vault_service.get_vault_settings(conn)["last_grant_ttl"],
)
- meta = vault_service.get_secret_meta(conn, name)
+ record_meta = _vault_record_meta(conn, requested_name)
+ name = str(record_meta.get("record_name") or requested_name)
+ meta = record_meta
if meta.get("protection") != "protected":
raise VaultApiError("agent binding is only valid for protected secrets", code="not_protected", status=409)
key = _load_or_create_vault_daemon_binding_key(conn)
if remember_duration:
vault_service.save_vault_settings(conn, {"last_grant_ttl": duration["last_grant_ttl"]})
except vault_service.SecretNotFoundError as exc:
- raise VaultApiError(f"secret '{name}' not found", code="secret_not_found", status=404) from exc
+ raise VaultApiError(
+ f"secret '{requested_name}' not found",
+ code="secret_not_found",
+ status=404,
+ ) from exc
except vault_service.VaultSecretAccessError as exc:
raise _vault_secret_access_forbidden(exc) from exc
except vault_service.RequestNotFoundError as exc:
@@ -2955,6 +3136,13 @@ def create_vault_agent_binding(payload: dict) -> dict:
raise VaultApiError(str(exc), code="invalid_request", status=409) from exc
except vault_service.InvalidGrantError as exc:
raise VaultApiError(str(exc), code="invalid_grant") from exc
+ except (
+ vault_service.InvalidFieldNameError,
+ vault_service.FieldNotFoundError,
+ vault_service.FieldsNotSupportedError,
+ vault_service.FieldsCorruptError,
+ ) as exc:
+ raise _vault_field_service_error(exc) from exc
except vault_service.VaultServiceError as exc:
raise VaultApiError(str(exc), code="vault_error") from exc
@@ -3023,13 +3211,28 @@ def create_vault_agent_binding(payload: dict) -> dict:
}
-def create_vault_reveal_context(name: str, payload: dict | None = None) -> dict:
+def create_vault_reveal_context(
+ name: str,
+ payload: dict | None = None,
+ *,
+ user_context: Any = None,
+) -> dict:
from storage import vault_crypto, vault_service
secret_name = str(name or "").strip()
if not vault_crypto.is_valid_secret_name(secret_name):
raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")
body = payload if isinstance(payload, dict) else {}
+ _reject_plaintext_value_fields(body)
+ field = body.get("field")
+ if field is not None and not isinstance(field, str):
+ raise VaultApiError("field must be a string", code="invalid_field_name", status=400)
+ field_name = None
+ if field is not None:
+ try:
+ field_name = _vault_validate_field_name(field, field="field")
+ except vault_service.InvalidFieldNameError as exc:
+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exc
try:
ttl_seconds = int(body.get("ttl_seconds") or body.get("ttlSecs") or 120)
except (TypeError, ValueError) as exc:
@@ -3040,12 +3243,20 @@ def create_vault_reveal_context(name: str, payload: dict | None = None) -> dict:
expires_at = datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)
try:
with engine.begin() as conn:
- meta = vault_service.get_secret_meta(conn, secret_name)
+ record_ref = secret_name if field_name is None else f"{secret_name}.{field_name}"
+ record_meta = _vault_record_meta(conn, record_ref, user_context=user_context)
+ meta = dict(record_meta)
if meta.get("protection") != "protected":
raise VaultApiError("reveal context is only valid for protected secrets", code="not_protected", status=409)
- envelope = vault_service.get_protected_record_envelope(conn, secret_name)
+ record_name = str(record_meta.get("record_name") or record_ref)
+ envelope = vault_service.get_protected_record_envelope(
+ conn,
+ record_name,
+ user_context=user_context,
+ )
key = _load_or_create_vault_daemon_binding_key(conn)
envelope_payload = _envelope_payload(envelope)
+ display_meta = {**meta, "name": record_name}
context = {
"v": 2,
"purpose": "reveal",
@@ -3059,10 +3270,10 @@ def create_vault_reveal_context(name: str, payload: dict | None = None) -> dict:
"source_selector": body.get("source") if isinstance(body.get("source"), dict) else {},
}
},
- [meta],
+ [display_meta],
),
"release": {
- "name": secret_name,
+ "name": record_name,
"envelopeHash": _envelope_hash(envelope_payload),
},
"expiresAt": _isoformat_z(expires_at),
@@ -3074,6 +3285,14 @@ def create_vault_reveal_context(name: str, payload: dict | None = None) -> dict:
raise _vault_secret_access_forbidden(exc) from exc
except vault_service.KeypairNotValueDeliverableError as exc:
raise VaultApiError(str(exc), code="keypair_not_value_deliverable", status=409) from exc
+ except (
+ vault_service.InvalidFieldNameError,
+ vault_service.FieldNotFoundError,
+ vault_service.FieldsNotSupportedError,
+ ) as exc:
+ raise _vault_field_service_error(exc) from exc
+ except vault_service.VaultServiceError as exc:
+ raise _vault_field_service_error(exc) from exc
return {"ok": True, "context": signed_context, "envelope": envelope_payload}
@@ -3218,7 +3437,7 @@ def _reject_plaintext_value_fields(payload: object) -> None:
_reject_plaintext_value_fields(item)
-_VAULT_METADATA_ALLOWED_FIELDS = {"description", "tags", "policy"}
+_VAULT_METADATA_ALLOWED_FIELDS = {"description", "tags", "policy", "default_field"}
_VAULT_METADATA_SECRET_FIELDS = {
"value",
"sealed",
@@ -3268,7 +3487,12 @@ def _sealed_from_payload(payload: dict):
return Sealed(ciphertext=ciphertext, nonce=nonce, wrap_meta=wrap_meta)
-def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:
+def create_vault_secret(
+ payload: dict,
+ *,
+ origin: str | None = None,
+ user_context: Any = None,
+) -> dict:
from storage import vault_crypto, vault_service
if not isinstance(payload, dict):
@@ -3294,9 +3518,28 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:
if signer_kind is not None:
signer_kind = str(signer_kind)
provision_request_id = str(payload.get("provision_request_id") or "") or None
+ if kind == "keypair" and ("fields" in payload or "default_field" in payload or "default_field" in (public_meta or {})):
+ raise VaultApiError(
+ "keypair secrets do not support fields or default_field",
+ code="fields_not_supported",
+ status=409,
+ )
+ if "default_field" in payload:
+ try:
+ default_field = _vault_validate_field_name(payload.get("default_field"), field="default_field")
+ except vault_service.InvalidFieldNameError as exc:
+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exc
+ else:
+ default_field = "value"
+ field_specs = _vault_create_field_specs(
+ payload,
+ secret_name=name,
+ kind=kind,
+ default_field=default_field,
+ )
atomic_protected_establishment = establishing_vmk and protection == "protected"
try:
- user_context = vault_service.require_secret_create_access()
+ user_context = vault_service.require_secret_create_access(user_context=user_context)
except vault_service.VaultSecretAccessError as exc:
raise _vault_secret_access_forbidden(exc) from exc
engine = _vault_engine()
@@ -3312,6 +3555,14 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:
)
except vault_service.InvalidSecretNameError as exc:
raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name") from exc
+ except (
+ vault_service.InvalidFieldNameError,
+ vault_service.FieldExistsError,
+ vault_service.TooManyFieldsError,
+ vault_service.FieldsNotSupportedError,
+ vault_service.RecordMismatchError,
+ ) as exc:
+ raise _vault_field_service_error(exc) from exc
except vault_service.SecretNameCaseConflictError as exc:
raise VaultApiError(
f"secret name '{name}' conflicts with existing secret '{exc.existing_name}'",
@@ -3349,12 +3600,26 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:
sealed = _sealed_from_payload(payload.get("sealed") or payload.get("envelope") or payload)
else:
raise VaultApiError("invalid protection tier", code="invalid_protection")
+ sealed_fields: list[dict[str, Any]] = []
+ for spec in field_specs:
+ field_name = str(spec["name"])
+ record_name = str(spec["record"])
+ if protection == "standard":
+ try:
+ field_sealed = avault_seal_blind_box(record_name, spec["blind_box"])
+ except AvaultError as exc:
+ raise VaultApiError(f"avault blind-box seal failed: {exc}", code="avault_failed") from exc
+ else:
+ field_sealed = _sealed_from_payload(spec["sealed"])
+ sealed_fields.append({"name": field_name, "record": record_name, "sealed": field_sealed})
try:
with engine.begin() as conn:
meta = vault_service.create_secret(
conn,
name=name,
sealed=sealed,
+ fields=sealed_fields,
+ default_field=default_field if kind != "keypair" else None,
tags=tags or None,
protection=protection,
kind=kind,
@@ -3370,6 +3635,14 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:
)
except vault_service.InvalidSecretNameError as exc:
raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name") from exc
+ except (
+ vault_service.InvalidFieldNameError,
+ vault_service.FieldExistsError,
+ vault_service.TooManyFieldsError,
+ vault_service.FieldsNotSupportedError,
+ vault_service.RecordMismatchError,
+ ) as exc:
+ raise _vault_field_service_error(exc) from exc
except vault_service.SecretNameCaseConflictError as exc:
raise VaultApiError(
f"secret name '{name}' conflicts with existing secret '{exc.existing_name}'",
@@ -3405,7 +3678,7 @@ def create_vault_secret(payload: dict, *, origin: str | None = None) -> dict:
return {"ok": True, "secret": meta}
-def update_vault_secret(name: str, payload: dict) -> dict:
+def update_vault_secret(name: str, payload: dict, *, user_context: Any = None) -> dict:
from storage import vault_crypto, vault_service
if not isinstance(payload, dict):
@@ -3428,11 +3701,26 @@ def update_vault_secret(name: str, payload: dict) -> dict:
release_scopes: list[dict[str, str]] = []
try:
with engine.begin() as conn:
- meta = vault_service.update_secret_metadata(conn, secret_name, release_scopes=release_scopes, **kwargs)
+ meta = vault_service.update_secret_metadata(
+ conn,
+ secret_name,
+ release_scopes=release_scopes,
+ user_context=user_context,
+ **kwargs,
+ )
except vault_service.SecretNotFoundError as exc:
raise VaultApiError(f"secret '{secret_name}' not found", code="secret_not_found", status=404) from exc
except vault_service.VaultSecretAccessError as exc:
raise _vault_secret_access_forbidden(exc) from exc
+ except (
+ vault_service.InvalidFieldNameError,
+ vault_service.FieldExistsError,
+ vault_service.TooManyFieldsError,
+ vault_service.FieldsNotSupportedError,
+ vault_service.FieldsCorruptError,
+ vault_service.SecretConflictError,
+ ) as exc:
+ raise _vault_field_service_error(exc) from exc
except vault_service.VaultServiceError as exc:
raise VaultApiError(str(exc), code="invalid_metadata", status=409) from exc
release_vault_agent_scopes(release_scopes, reason="update_vault_secret")
@@ -3440,6 +3728,181 @@ def update_vault_secret(name: str, payload: dict) -> dict:
return {"ok": True, "secret": meta}
+def update_vault_secret_field(
+ name: str,
+ field: str,
+ payload: dict,
+ *,
+ user_context: Any = None,
+) -> dict:
+ from storage import vault_crypto, vault_service
+
+ if not isinstance(payload, dict):
+ raise VaultApiError("payload must be an object", code="invalid_payload")
+ _reject_plaintext_value_fields(payload)
+ secret_name = str(name or "").strip()
+ if not vault_crypto.is_valid_secret_name(secret_name):
+ raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")
+ try:
+ field_name = _vault_validate_field_name(field)
+ except vault_service.InvalidFieldNameError as exc:
+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exc
+ allowed = {"record", "blind_box", "sealed", "expected_updated_at"}
+ extra = set(payload) - allowed
+ if extra:
+ raise VaultApiError(
+ f"unsupported vault field payload fields: {', '.join(sorted(extra))}",
+ code="invalid_request",
+ status=409,
+ )
+ if "record" not in payload:
+ raise VaultApiError("record is required", code="invalid_request", status=409)
+ record = payload["record"]
+ if not isinstance(record, str):
+ raise VaultApiError("record must be a string", code="record_mismatch", status=409)
+ expected_supplied = "expected_updated_at" in payload
+ expected_updated_at = payload.get("expected_updated_at")
+ if expected_supplied and expected_updated_at is not None and not isinstance(expected_updated_at, str):
+ raise VaultApiError("expected_updated_at must be a string", code="invalid_request", status=409)
+
+ engine = _vault_engine()
+ try:
+ with engine.connect() as conn:
+ meta = _vault_secret_management_meta(
+ conn,
+ secret_name,
+ user_context=user_context,
+ )
+ except vault_service.SecretNotFoundError as exc:
+ raise VaultApiError(f"secret '{secret_name}' not found", code="secret_not_found", status=404) from exc
+ except vault_service.VaultServiceError as exc:
+ raise _vault_field_service_error(exc) from exc
+
+ if meta.get("kind") == "keypair":
+ raise VaultApiError(
+ f"{secret_name} does not support fields",
+ code="fields_not_supported",
+ status=409,
+ )
+ default_field = str(meta.get("default_field") or "value")
+ record_name = secret_name if field_name == default_field else f"{secret_name}.{field_name}"
+ if record != record_name:
+ raise VaultApiError(
+ f"record does not match field {field_name!r} on {secret_name}",
+ code="record_mismatch",
+ status=409,
+ )
+ snapshot_updated_at = meta.get("updated_at")
+ if expected_supplied and expected_updated_at != snapshot_updated_at:
+ raise VaultApiError(
+ f"secret '{secret_name}' changed while the field was being updated",
+ code="secret_conflict",
+ status=409,
+ )
+
+ protection = str(meta.get("protection") or "standard")
+ if protection == "standard":
+ if "sealed" in payload:
+ raise VaultApiError("standard field updates require blind_box", code="invalid_request", status=409)
+ blind_box = payload.get("blind_box")
+ if not isinstance(blind_box, dict):
+ raise VaultApiError("standard field update requires a browser blind_box", code="blind_box_required")
+ try:
+ sealed = avault_seal_blind_box(record_name, blind_box)
+ except AvaultError as exc:
+ raise VaultApiError(f"avault blind-box seal failed: {exc}", code="avault_failed") from exc
+ elif protection == "protected":
+ if "blind_box" in payload:
+ raise VaultApiError("protected field updates require sealed", code="invalid_request", status=409)
+ sealed = _sealed_from_payload(payload.get("sealed") or payload)
+ else:
+ raise VaultApiError("invalid protection tier", code="invalid_protection")
+
+ release_scopes: list[dict[str, str]] = []
+ try:
+ with engine.begin() as conn:
+ meta = vault_service.update_secret_field(
+ conn,
+ secret_name,
+ field_name,
+ sealed,
+ record=record,
+ expected_updated_at=snapshot_updated_at,
+ release_scopes=release_scopes,
+ user_context=user_context,
+ )
+ except vault_service.VaultServiceError as exc:
+ raise _vault_field_service_error(exc) from exc
+ release_vault_agent_scopes(release_scopes, reason="update_vault_secret_field")
+ _publish_vaults_updated(scope="secret", secret_name=meta.get("name") or secret_name)
+ return {"ok": True, "secret": meta}
+
+
+def delete_vault_secret_field(
+ name: str,
+ field: str,
+ payload: dict | None = None,
+ *,
+ user_context: Any = None,
+) -> dict:
+ from storage import vault_crypto, vault_service
+
+ body = {} if payload is None else payload
+ if not isinstance(body, dict):
+ raise VaultApiError("payload must be an object", code="invalid_payload")
+ _reject_plaintext_value_fields(body)
+ if set(body) - {"expected_updated_at"}:
+ raise VaultApiError("unsupported field delete payload", code="invalid_request", status=409)
+ expected_supplied = "expected_updated_at" in body
+ expected_updated_at = body.get("expected_updated_at")
+ if expected_supplied and not isinstance(expected_updated_at, str):
+ raise VaultApiError("expected_updated_at must be a string", code="invalid_request", status=409)
+ secret_name = str(name or "").strip()
+ if not vault_crypto.is_valid_secret_name(secret_name):
+ raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")
+ try:
+ field_name = _vault_validate_field_name(field)
+ except vault_service.InvalidFieldNameError as exc:
+ raise VaultApiError(str(exc), code="invalid_field_name", status=400) from exc
+ engine = _vault_engine()
+ try:
+ with engine.connect() as conn:
+ meta = _vault_secret_management_meta(
+ conn,
+ secret_name,
+ user_context=user_context,
+ )
+ except vault_service.SecretNotFoundError as exc:
+ raise VaultApiError(f"secret '{secret_name}' not found", code="secret_not_found", status=404) from exc
+ except vault_service.VaultServiceError as exc:
+ raise _vault_field_service_error(exc) from exc
+ if meta.get("kind") == "keypair":
+ raise VaultApiError(
+ f"{secret_name} does not support fields",
+ code="fields_not_supported",
+ status=409,
+ )
+ snapshot_updated_at = meta.get("updated_at")
+ if expected_supplied and expected_updated_at != snapshot_updated_at:
+ raise _vault_field_service_error(vault_service.SecretConflictError(f"secret '{secret_name}' changed before field removal"))
+ release_scopes: list[dict[str, str]] = []
+ try:
+ with engine.begin() as conn:
+ updated = vault_service.remove_secret_field(
+ conn,
+ secret_name,
+ field_name,
+ expected_updated_at=expected_updated_at if expected_supplied else snapshot_updated_at,
+ release_scopes=release_scopes,
+ user_context=user_context,
+ )
+ except vault_service.VaultServiceError as exc:
+ raise _vault_field_service_error(exc) from exc
+ release_vault_agent_scopes(release_scopes, reason="delete_vault_secret_field")
+ _publish_vaults_updated(scope="secret", secret_name=updated.get("name") or secret_name)
+ return {"ok": True, "secret": updated}
+
+
def delete_vault_secret(name: str) -> dict:
from storage import vault_service
@@ -3474,7 +3937,12 @@ def get_vault_audit(*, secret_name: Optional[str] = None, limit: int = 100) -> d
def get_vault_requests(
- *, status: Optional[str] = "pending", request_type: Optional[str] = None, limit: int = 100, session: Optional[str] = None
+ *,
+ status: Optional[str] = "pending",
+ request_type: Optional[str] = None,
+ limit: int = 100,
+ session: Optional[str] = None,
+ user_context: Any = None,
) -> dict:
from storage import vault_service
@@ -3576,14 +4044,24 @@ def _vault_request_result(conn, request: dict) -> dict | None:
return None
-def get_vault_request(request_id: str, *, audience: str | None = None) -> dict:
+def get_vault_request(
+ request_id: str,
+ *,
+ audience: str | None = None,
+ user_context: Any = None,
+) -> dict:
from storage import vault_service
request_audience = audience or vault_service.REQUEST_AUDIENCE_AGENT
engine = _vault_engine()
try:
with engine.begin() as conn:
- request = vault_service.get_request(conn, request_id, audience=request_audience)
+ request = vault_service.get_request(
+ conn,
+ request_id,
+ audience=request_audience,
+ user_context=user_context,
+ )
result = _vault_request_result(conn, request)
except vault_service.RequestNotFoundError as exc:
raise VaultApiError(f"request '{request_id}' not found", code="request_not_found", status=404) from exc
@@ -3646,24 +4124,29 @@ def _expires_at_from_ttl(payload: dict) -> str | None:
return (datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)).isoformat()
-def request_vault_access(payload: dict) -> dict:
+def request_vault_access(payload: dict, *, user_context: Any = None) -> dict:
from storage import vault_crypto, vault_service
if not isinstance(payload, dict):
raise VaultApiError("payload must be an object", code="invalid_payload")
- name = str(payload.get("name") or "").strip()
+ raw_name = payload.get("name")
+ name = raw_name if isinstance(raw_name, str) else ""
+ if "." not in name:
+ name = name.strip()
raw_selector = payload.get("source_selector")
source_selector = dict(raw_selector) if isinstance(raw_selector, dict) else None
if not name and source_selector is None:
raise VaultApiError("name or source_selector is required", code="invalid_request", status=409)
- if name and not vault_crypto.is_valid_secret_name(name):
- raise VaultApiError("invalid secret name (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name")
+ if name and not vault_crypto.is_valid_secret_name(name.split(".", 1)[0]):
+ raise VaultApiError("invalid secret reference", code="invalid_name")
purpose = str(payload.get("purpose") or "run")
engine = _vault_engine()
try:
with engine.begin() as conn:
if name:
- vault_service.get_secret_meta(conn, name)
+ if "." in name:
+ vault_service.validate_field_name(name.split(".", 1)[1])
+ vault_service.get_secret_record_meta(conn, name, user_context=user_context)
request = vault_service.create_access_request(
conn,
name or None,
@@ -3673,6 +4156,7 @@ def request_vault_access(payload: dict) -> dict:
delivery=_vault_delivery_payload(payload),
expires_at=_expires_at_from_ttl(payload),
audience=vault_service.REQUEST_AUDIENCE_AGENT,
+ user_context=user_context,
)
except vault_service.SecretNotFoundError as exc:
missing_name = name or str(exc)
@@ -3683,6 +4167,13 @@ def request_vault_access(payload: dict) -> dict:
raise VaultApiError(str(exc), code="not_grantable", status=409) from exc
except vault_service.KeypairNotValueDeliverableError as exc:
raise VaultApiError(str(exc), code="keypair_not_value_deliverable", status=409) from exc
+ except (
+ vault_service.FieldNotFoundError,
+ vault_service.FieldsCorruptError,
+ vault_service.InvalidFieldNameError,
+ vault_service.FieldsNotSupportedError,
+ ) as exc:
+ raise _vault_field_service_error(exc) from exc
except vault_service.InvalidRequestError as exc:
raise VaultApiError(str(exc), code="invalid_request", status=409) from exc
except vault_service.VaultServiceError as exc:
@@ -3697,7 +4188,7 @@ def request_vault_access(payload: dict) -> dict:
return {"ok": True, "request": request}
-def request_vault_sign(payload: dict) -> dict:
+def request_vault_sign(payload: dict, *, user_context: Any = None) -> dict:
from storage import vault_crypto, vault_service
if not isinstance(payload, dict):
@@ -3712,7 +4203,7 @@ def request_vault_sign(payload: dict) -> dict:
engine = _vault_engine()
try:
with engine.begin() as conn:
- meta = vault_service.get_secret_meta(conn, name)
+ meta = vault_service.get_secret_meta(conn, name, user_context=user_context)
if meta.get("kind") != "keypair":
raise VaultApiError(f"secret '{name}' is not a signing key", code="not_signing_key", status=409)
if (meta.get("signer_kind") or "local") != "local":
@@ -3735,6 +4226,7 @@ def request_vault_sign(payload: dict) -> dict:
requester=_vault_ui_requester_payload(payload),
delivery=_vault_delivery_payload(payload),
expires_at=_expires_at_from_ttl(payload),
+ user_context=user_context,
)
except vault_service.SecretNotFoundError as exc:
raise VaultApiError(f"secret '{name}' not found", code="secret_not_found", status=404) from exc
@@ -3935,6 +4427,7 @@ def _resident_agent_deks_from_payload(payload: dict, *, needs_agent_deks: bool)
raise VaultApiError("resident agent grant requires sealed DEKs", code="invalid_grant")
agent_deks: list[dict[str, Any]] = []
allowed_keys = {"name", "dek_blindbox", "approval"}
+ seen_names: set[str] = set()
for item in deks:
if not isinstance(item, dict):
raise VaultApiError("resident agent grant DEKs must be objects", code="invalid_grant")
@@ -3946,6 +4439,9 @@ def _resident_agent_deks_from_payload(payload: dict, *, needs_agent_deks: bool)
approval = item.get("approval")
if not isinstance(name, str) or not name or not isinstance(dek_blindbox, dict) or not isinstance(approval, dict):
raise VaultApiError("resident agent grant DEKs require name, dek_blindbox, and approval", code="invalid_grant")
+ if name in seen_names:
+ raise VaultApiError("resident agent grant DEKs must contain unique record names", code="invalid_grant")
+ seen_names.add(name)
agent_deks.append(
{
"name": name,
@@ -4220,14 +4716,20 @@ def create_vault_grant(payload: dict) -> dict:
if not grantable_members:
raise VaultApiError("grant has no grantable static secrets", code="not_grantable", status=409)
protected_member_names = {str(member["name"]) for member in grantable_members if member.get("protection") == "protected"}
- needs_agent_deks = bool(protected_member_names)
+ protected_record_names = {
+ record_name
+ for member in grantable_members
+ if member.get("protection") == "protected"
+ for record_name in _vault_secret_record_names(member)
+ }
+ needs_agent_deks = bool(protected_record_names)
binding_grant_expires_at: str | None = None
binding_operation_ttl_seconds: int | None = None
agent_deks = _resident_agent_deks_from_payload(payload, needs_agent_deks=needs_agent_deks)
provided_names = {item["name"] for item in agent_deks}
- if needs_agent_deks and provided_names != protected_member_names:
- raise VaultApiError("resident agent DEKs must match the protected grant members", code="invalid_grant")
+ if needs_agent_deks and provided_names != protected_record_names:
+ raise VaultApiError("resident agent DEKs must match the protected grant records", code="invalid_grant")
expected_member_names = {str(member["name"]) for member in grantable_members} if needs_agent_deks else None
expected_pubkey = payload.get("agent_pubkey") if isinstance(payload.get("agent_pubkey"), dict) else None
if needs_agent_deks:
@@ -4952,6 +5454,8 @@ def store_vault_pubkey_pin(payload: dict) -> dict:
raise VaultApiError(f"secret '{name}' not found", code="secret_not_found", status=404) from exc
except vault_service.VaultSecretAccessError as exc:
raise _vault_secret_access_forbidden(exc) from exc
+ except vault_service.SecretConflictError as exc:
+ raise _vault_field_service_error(exc) from exc
_publish_vaults_updated(scope="secret", secret_name=meta.get("name") or name)
return {"ok": True, "secret": meta}
diff --git a/vibe/cli.py b/vibe/cli.py
index 433323aed..034e212df 100644
--- a/vibe/cli.py
+++ b/vibe/cli.py
@@ -8323,14 +8323,20 @@ def _is_env_name(name: str) -> bool:
return all(c.isascii() and (c.isalnum() or c == "_") for c in name)
-def _parse_env_specs_parts(specs) -> tuple[dict[str, str], list[str]]:
+def _parse_env_specs_parts(
+ specs,
+ *,
+ help_command: str = "vibe vault run --help",
+) -> tuple[dict[str, str], list[str]]:
"""Map ENV var name -> vault secret name from ``--env`` specs.
Accepts ``NAME`` (inject as the same name), ``LOCAL=NAME`` (rename), and
comma-separated ``A,B`` within one flag.
"""
+ from storage import vault_service
+
mapping: dict[str, str] = {}
- env_by_secret: dict[str, str] = {}
+ env_by_record: dict[str, str] = {}
normalized: list[str] = []
for spec in specs or []:
for part in str(spec).split(","):
@@ -8342,32 +8348,37 @@ def _parse_env_specs_parts(specs) -> tuple[dict[str, str], list[str]]:
local, vault_name = local.strip(), vault_name.strip()
else:
local = vault_name = part
+ if "." in vault_name:
+ base, _, field = vault_name.partition(".")
+ local = f"{base}_{field.upper()}"
if not local or not vault_name:
- raise TaskCliError(f"invalid --env spec: {part!r}", code="invalid_env_spec", help_command="vibe vault run --help")
+ raise TaskCliError(f"invalid --env spec: {part!r}", code="invalid_env_spec", help_command=help_command)
+ if "." in vault_name:
+ vault_service.validate_field_name(vault_name.partition(".")[2])
# The local (LHS) becomes an env var name / is interpolated into `export`
# lines for eval — reject anything that isn't a plain identifier so it can't
# break the shell or smuggle in extra commands.
if not _is_env_name(local):
- raise TaskCliError(f"invalid env var name: {local!r} (use [A-Za-z_][A-Za-z0-9_]*)", code="invalid_env_name", help_command="vibe vault run --help")
+ raise TaskCliError(f"invalid env var name: {local!r} (use [A-Za-z_][A-Za-z0-9_]*)", code="invalid_env_name", help_command=help_command)
existing = mapping.get(local)
if existing is not None and existing != vault_name:
raise TaskCliError(
f"env var {local!r} maps to both {existing!r} and {vault_name!r}",
code="conflicting_env_alias",
- help_command="vibe vault run --help",
+ help_command=help_command,
)
- existing_env = env_by_secret.get(vault_name)
+ existing_env = env_by_record.get(vault_name)
if existing_env is not None and existing_env != local:
raise TaskCliError(
f"secret '{vault_name}' was selected as both {existing_env!r} and {local!r}",
code="conflicting_env_alias",
hint="Use one --env alias for each selected secret.",
- help_command="vibe vault run --help",
+ help_command=help_command,
)
if existing == vault_name:
continue
mapping[local] = vault_name
- env_by_secret[vault_name] = local
+ env_by_record[vault_name] = local
normalized.append(vault_name if local == vault_name else f"{local}={vault_name}")
return mapping, normalized
@@ -8376,6 +8387,10 @@ def _parse_env_specs(specs) -> dict:
return _parse_env_specs_parts(specs)[0]
+def _record_secret_name(record: str) -> str:
+ return str(record).split(".", 1)[0]
+
+
def _arg_list(args, name: str) -> list[str]:
value = getattr(args, name, None)
if value is None:
@@ -8391,6 +8406,7 @@ def _add_vault_run_selection(
*,
vault_name: str,
env_name: str,
+ help_command: str = "vibe vault run --help",
) -> None:
if not vault_name or not env_name:
raise TaskCliError("vault run selector produced an empty secret or env name", code="invalid_selector")
@@ -8400,7 +8416,7 @@ def _add_vault_run_selection(
raise TaskCliError(
f"env var {env_name!r} is selected for both {existing_secret!r} and {vault_name!r}",
code="conflicting_env_alias",
- help_command="vibe vault run --help",
+ help_command=help_command,
)
return
existing_env = next((selected_env for selected_env, selected_secret in selections.items() if selected_secret == vault_name), None)
@@ -8409,51 +8425,70 @@ def _add_vault_run_selection(
f"secret '{vault_name}' was selected as both {existing_env!r} and {env_name!r}",
code="conflicting_env_alias",
hint="Use one --env alias for each selected secret.",
- help_command="vibe vault run --help",
+ help_command=help_command,
)
selections[env_name] = vault_name
-def _resolve_vault_run_selectors(engine, args) -> tuple[dict[str, str], dict]:
- """Expand --env/--tag/--skill to a fixed env-name -> vault-name plan."""
+def _resolve_vault_run_selectors(
+ engine,
+ args,
+ *,
+ help_command: str = "vibe vault run --help",
+) -> tuple[dict[str, str], dict]:
+ """Expand --env/--tag/--skill to a canonical env-name -> record plan."""
from storage import vault_service
env_specs = list(getattr(args, "env", None) or [])
- explicit_mapping, normalized_env_specs = _parse_env_specs_parts(env_specs)
+ normalized_env_specs: list[str] = []
+ for spec in env_specs:
+ for part in str(spec).split(","):
+ # Conflicts belong to the canonical record plan: NAME and NAME.default
+ # may name the same record under the same alias.
+ _, normalized = _parse_env_specs_parts([part], help_command=help_command)
+ normalized_env_specs.extend(normalized)
tag_specs = _arg_list(args, "tag")
skill_specs = _arg_list(args, "skill")
selector_requested = bool(normalized_env_specs or tag_specs or skill_specs)
selections: dict[str, str] = {}
- for env_name, vault_name in explicit_mapping.items():
- _add_vault_run_selection(selections, vault_name=vault_name, env_name=env_name)
-
- source_selector: dict = {"env": normalized_env_specs}
- if tag_specs or skill_specs:
+ selector = {
+ "env": normalized_env_specs,
+ "tags": tag_specs,
+ "skills": skill_specs,
+ }
+ try:
with engine.connect() as conn:
- expanded = vault_service.expand_value_delivery_selector(conn, tags=tag_specs, skills=skill_specs)
- source_selector["tags"] = list(expanded["source_selector"].get("tags") or [])
- for item in expanded.get("secrets") or []:
- _add_vault_run_selection(
- selections,
- vault_name=str(item.get("name") or ""),
- env_name=str(item.get("env") or ""),
+ expanded = vault_service.expand_value_delivery_selector(
+ conn,
+ source_selector=selector,
)
- else:
- source_selector["tags"] = []
+ except vault_service.InvalidRequestError as exc:
+ message = str(exc)
+ code = "conflicting_env_alias" if "conflict" in message or "maps to multiple" in message else "invalid_selector"
+ raise TaskCliError(message, code=code, help_command=help_command) from exc
+
+ for item in expanded.get("secrets") or []:
+ _add_vault_run_selection(
+ selections,
+ vault_name=str(item.get("record") or ""),
+ env_name=str(item.get("env") or ""),
+ help_command=help_command,
+ )
+ source_selector = dict(expanded.get("source_selector") or {})
if not selections and selector_requested:
raise TaskCliError(
"vault run selector matched no value-deliverable secrets",
code="no_matching_secrets",
hint="Check the --env, --tag, or --skill selector, or ask the user to store/link the secret first.",
- help_command="vibe vault run --help",
+ help_command=help_command,
)
if not selections:
raise TaskCliError(
"at least one --env NAME, --tag TAG, or --skill SKILL is required",
code="missing_selector",
- help_command="vibe vault run --help",
+ help_command=help_command,
)
return selections, source_selector
@@ -8523,10 +8558,14 @@ def _vault_lookup_next_steps(*, has_more: bool, has_filters: bool) -> list[str]:
def _vault_capability_payload(secret: dict) -> dict:
+ default_field = secret.get("default_field") or "value"
return {
"name": secret["name"],
"kind": secret.get("kind"),
"protection": secret.get("protection"),
+ "default_field": default_field,
+ "fields": secret.get("fields") or [default_field],
+ **({"fields_state": "corrupt"} if secret.get("fields_state") == "corrupt" else {}),
"tags": secret.get("tags") or [],
"description": secret.get("description"),
"policy": secret.get("policy") or {},
@@ -8887,6 +8926,9 @@ def cmd_vault_edit(args):
except vault_service.SecretNotFoundError:
_print_task_error(TaskCliError(f"secret '{args.name}' not found", code="secret_not_found", help_command=help_command))
return 1
+ except vault_service.SecretConflictError as exc:
+ _print_task_error(TaskCliError(str(exc), code="secret_conflict", help_command=help_command))
+ return 1
except vault_service.VaultServiceError as exc:
_print_task_error(TaskCliError(str(exc), code="invalid_metadata", help_command=help_command))
return 1
@@ -8904,16 +8946,18 @@ def cmd_vault_access(args):
help_command = "vibe vault access --help"
name = getattr(args, "name", "")
try:
- if not vault_crypto.is_valid_secret_name(name):
- raise TaskCliError(f"invalid secret name: {name!r} (use ^[A-Za-z_][A-Za-z0-9_]*$)", code="invalid_name", help_command=help_command)
+ if not vault_crypto.is_valid_secret_name(_record_secret_name(name)):
+ raise TaskCliError(f"invalid secret reference: {name!r}", code="invalid_name", help_command=help_command)
engine = _open_vault_engine()
with engine.begin() as conn:
- vault_service.get_secret_meta(conn, name)
+ record_meta = vault_service.get_secret_record_meta(conn, name)
+ secret_name = str(record_meta["name"])
+ record_name = str(record_meta["record_name"])
request = vault_service.create_access_request(
conn,
- name,
+ secret_name,
requester=_vault_cli_requester(args),
- delivery=_vault_cli_delivery(args, mode="access"),
+ delivery={**_vault_cli_delivery(args, mode="access"), "record": record_name},
)
_publish_cli_vaults_updated(scope="request", request=request)
_print_cli_payload(
@@ -8926,6 +8970,18 @@ def cmd_vault_access(args):
except vault_service.SecretNotFoundError:
_print_task_error(TaskCliError(f"secret '{name}' not found", code="secret_not_found", help_command=help_command))
return 1
+ except vault_service.InvalidFieldNameError as exc:
+ _print_task_error(TaskCliError(str(exc), code="invalid_field_name", help_command=help_command))
+ return 1
+ except vault_service.FieldsCorruptError as exc:
+ _print_task_error(TaskCliError(str(exc), code="fields_corrupt", help_command=help_command))
+ return 1
+ except vault_service.FieldNotFoundError as exc:
+ _print_task_error(TaskCliError(str(exc), code="field_not_found", help_command=help_command))
+ return 1
+ except vault_service.FieldsNotSupportedError as exc:
+ _print_task_error(TaskCliError(str(exc), code="fields_not_supported", help_command=help_command))
+ return 1
except vault_service.NotGrantableError as exc:
_print_task_error(TaskCliError(str(exc), code="not_grantable", help_command=help_command))
return 1
@@ -9000,41 +9056,43 @@ def _vault_cli_delivery_context(args, *, mode: str, **extra) -> tuple[dict, dict
return requester, delivery, session_id
-def _preflight_vault_names(engine, names: list[str], *, mixed_message: str, mixed_code: str = "mixed_protection_tiers") -> dict[str, dict]:
+def _preflight_vault_run_batch(engine, mapping: dict[str, str]) -> dict[str, dict]:
from storage import vault_service
metas: dict[str, dict] = {}
with engine.connect() as conn:
- for name in dict.fromkeys(names):
+ for record in dict.fromkeys(mapping.values()):
+ name = _record_secret_name(record)
+ if name in metas:
+ continue
metas[name] = vault_service.get_secret_meta(conn, name)
- tiers = {str(meta.get("protection") or "standard") for meta in metas.values()}
- if len(tiers) > 1:
- raise TaskCliError(mixed_message, code=mixed_code)
+ if metas[name].get("kind") == "keypair":
+ raise vault_service.KeypairNotValueDeliverableError(
+ f"{record} is a signing key; use vibe vault sign instead of value delivery"
+ )
return metas
-def _preflight_vault_run_batch(engine, mapping: dict[str, str]) -> dict[str, dict]:
+def _preflight_vault_inject_batch(engine, names: list[str]) -> dict[str, dict]:
from storage import vault_service
metas: dict[str, dict] = {}
with engine.connect() as conn:
- for name in dict.fromkeys(mapping.values()):
+ for record in dict.fromkeys(names):
+ name = _record_secret_name(record)
+ if name in metas:
+ continue
metas[name] = vault_service.get_secret_meta(conn, name)
if metas[name].get("kind") == "keypair":
raise vault_service.KeypairNotValueDeliverableError(
- f"{name} is a signing key; use vibe vault sign instead of value delivery"
+ f"{record} is a signing key; use vibe vault sign instead of value delivery"
)
+ tiers = {str(meta.get("protection") or "standard") for meta in metas.values()}
+ if len(tiers) > 1:
+ raise TaskCliError("mixing protected and standard secrets in one vault inject is not wired yet", code="mixed_protection_tiers")
return metas
-def _preflight_vault_inject_batch(engine, names: list[str]) -> dict[str, dict]:
- return _preflight_vault_names(
- engine,
- names,
- mixed_message="mixing protected and standard secrets in one vault inject is not wired yet",
- )
-
-
class _AgentRunOutputBridge:
"""Stream protected child stdio through temporary FIFOs owned by this CLI."""
@@ -9400,6 +9458,17 @@ def _finish_one_shot_after_avault_error(
_consume_after_possible_use(grants, reason=reason)
+def _capture_vault_delivery_identities(engine, names: list[str], grants):
+ from storage import vault_service
+
+ try:
+ with engine.connect() as conn:
+ return vault_service.capture_delivery_identities(conn, names)
+ except Exception:
+ _release_one_shot_reservations(engine, grants)
+ raise
+
+
def _resolve_vault_run_delivery(
engine,
mapping: dict[str, str],
@@ -9416,14 +9485,14 @@ def _resolve_vault_run_delivery(
metas = _preflight_vault_run_batch(engine, mapping)
protected_names = [
name
- for name in dict.fromkeys(mapping.values())
+ for name in dict.fromkeys(_record_secret_name(record) for record in mapping.values())
if str(metas[name].get("protection") or "standard") == "protected"
]
standard_approval_error: TaskCliError | None = None
approval_request_to_publish: dict | None = None
if metas and not protected_names:
with engine.begin() as conn:
- standard_names = list(dict.fromkeys(mapping.values()))
+ standard_names = list(dict.fromkeys(_record_secret_name(record) for record in mapping.values()))
approval_names = _always_ask_names(metas, standard_names)
common_grant = vault_service.find_active_grant_for_secrets(
conn,
@@ -9434,8 +9503,13 @@ def _resolve_vault_run_delivery(
)
if isinstance(common_grant, dict) and common_grant.get("one_shot") is True:
return None, [common_grant], [
- {"name": vault_name, "env": env_name, "envelope": vault_service.get_envelope(conn, vault_name)}
- for env_name, vault_name in mapping.items()
+ {
+ "name": record,
+ "env": env_name,
+ "envelope": vault_service.get_envelope(conn, record),
+ "tier": "standard",
+ }
+ for env_name, record in mapping.items()
]
if approval_names and _source_selector_tags(source_selector):
req = vault_service.create_access_request(
@@ -9466,7 +9540,7 @@ def _resolve_vault_run_delivery(
needs_selector_set = _needs_protected_selector_set(protected_names, source_selector)
selector_standard_names = [
name
- for name in dict.fromkeys(mapping.values())
+ for name in dict.fromkeys(_record_secret_name(record) for record in mapping.values())
if name not in protected_names and str(metas[name].get("protection") or "standard") == "standard"
]
selector_standard_approval_names = _always_ask_names(metas, selector_standard_names)
@@ -9532,15 +9606,16 @@ def _resolve_vault_run_delivery(
)
elif grant.get("one_shot") is True:
one_shot_grants.append(grant)
- for env_name, vault_name in mapping.items():
+ for env_name, record in mapping.items():
+ vault_name = _record_secret_name(record)
if approval_error is not None:
break
if vault_name in protected_names:
secrets.append(
{
- "name": vault_name,
+ "name": record,
"env": env_name,
- "envelope": vault_service.get_protected_envelope(conn, vault_name),
+ "envelope": vault_service.get_protected_envelope(conn, record),
"tier": "protected",
}
)
@@ -9549,7 +9624,7 @@ def _resolve_vault_run_delivery(
if resolved is None:
resolved = vault_service.resolve_secret_access(
conn,
- vault_name,
+ record,
purpose="run",
requester=requester,
delivery=delivery,
@@ -9570,9 +9645,12 @@ def _resolve_vault_run_delivery(
current_grant = resolved.get("grant")
if isinstance(current_grant, dict) and current_grant.get("one_shot") is True:
one_shot_grants.append(current_grant)
- item = {"name": vault_name, "env": env_name, "envelope": resolved["envelope"]}
- if protected_names:
- item["tier"] = "standard"
+ item = {
+ "name": record,
+ "env": env_name,
+ "envelope": vault_service.get_envelope(conn, record),
+ "tier": "standard",
+ }
secrets.append(item)
continue
if resolved["status"] == "agent_delivery_ready":
@@ -9624,41 +9702,103 @@ def _resolve_single_vault_delivery(
raise TaskCliError(f"unsupported vault access status: {resolved['status']}", code="vault_access_error")
-def _resolve_vault_inject_delivery(engine, names: list[str], *, path: str, fmt: str, args=None):
+def _resolve_vault_inject_delivery(
+ engine,
+ mapping: dict[str, str],
+ *,
+ path: str,
+ fmt: str,
+ args=None,
+ source_selector: dict | None = None,
+):
from storage import vault_service
requester, delivery, session_id = _vault_cli_delivery_context(args, mode="inject", path=path, format=fmt)
+ names = list(mapping.values())
+ secret_names = list(dict.fromkeys(_record_secret_name(record) for record in names))
metas = _preflight_vault_inject_batch(engine, names)
+ if source_selector:
+ delivery["source_selector"] = source_selector
tiers = {str(meta.get("protection") or "standard") for meta in metas.values()}
if metas and tiers == {"protected"}:
+ approval_request = None
with engine.begin() as conn:
common_grant = vault_service.find_active_grant_for_secrets(
conn,
- names,
+ secret_names,
session_id=session_id,
purpose="inject",
reserve_one_shot=True,
)
if common_grant is not None:
return common_grant, [common_grant] if common_grant.get("one_shot") is True else [], [
- {"name": name, "key": name, "envelope": vault_service.get_protected_envelope(conn, name)}
- for name in names
+ {
+ "name": record,
+ "key": env_name,
+ "envelope": vault_service.get_protected_envelope(conn, record),
+ "tier": "protected",
+ }
+ for env_name, record in mapping.items()
]
+ if (
+ _needs_protected_selector_set(secret_names, source_selector)
+ and not _always_ask_names(metas, secret_names)
+ ):
+ request_delivery = dict(delivery)
+ request_delivery["protected_secret_names"] = secret_names
+ approval_request = vault_service.create_access_request(
+ conn,
+ None,
+ source_selector=source_selector,
+ requester=requester,
+ delivery=request_delivery,
+ purpose="inject",
+ )
+ if approval_request is not None:
+ _publish_cli_vaults_updated(scope="request", request=approval_request)
+ raise TaskCliError(
+ "protected secrets need approval before vault inject delivery",
+ code="approval_required",
+ details={"request_id": approval_request.get("id"), "protected_secret_names": secret_names},
+ )
if metas and tiers == {"standard"}:
+ approval_request = None
+ approval_names = _always_ask_names(metas, secret_names)
with engine.begin() as conn:
standard_secrets = [
- {"name": name, "key": name, "envelope": vault_service.get_envelope(conn, name)}
- for name in names
+ {
+ "name": record,
+ "key": env_name,
+ "envelope": vault_service.get_envelope(conn, record),
+ "tier": "standard",
+ }
+ for env_name, record in mapping.items()
]
common_grant = vault_service.find_active_grant_for_secrets(
conn,
- names,
+ approval_names or secret_names,
session_id=session_id,
purpose="inject",
reserve_one_shot=True,
)
if isinstance(common_grant, dict) and common_grant.get("one_shot") is True:
return None, [common_grant], standard_secrets
+ if approval_names and _source_selector_tags(source_selector):
+ approval_request = vault_service.create_access_request(
+ conn,
+ None,
+ source_selector=source_selector,
+ requester=requester,
+ delivery=delivery,
+ purpose="inject",
+ )
+ if approval_request is not None:
+ _publish_cli_vaults_updated(scope="request", request=approval_request)
+ raise TaskCliError(
+ "standard always_ask secrets need approval before vault inject delivery",
+ code="approval_required",
+ details={"request_id": approval_request.get("id"), "secret_names": approval_names},
+ )
secrets = []
grant: dict | None = None
one_shot_grants: list[dict] = []
@@ -9668,12 +9808,13 @@ def _resolve_vault_inject_delivery(engine, names: list[str], *, path: str, fmt:
resolved_by_name: dict[str, dict] = {}
try:
with engine.begin() as conn:
- for name in names:
+ for env_name, record in mapping.items():
+ name = _record_secret_name(record)
resolved = resolved_by_name.get(name)
if resolved is None:
resolved = vault_service.resolve_secret_access(
conn,
- name,
+ record,
purpose="inject",
requester=requester,
delivery=delivery,
@@ -9694,7 +9835,15 @@ def _resolve_vault_inject_delivery(engine, names: list[str], *, path: str, fmt:
current_grant = resolved.get("grant")
if isinstance(current_grant, dict) and current_grant.get("one_shot") is True:
one_shot_grants.append(current_grant)
- secrets.append({"name": name, "key": name, "envelope": resolved["envelope"], "protected": False})
+ secrets.append(
+ {
+ "name": record,
+ "key": env_name,
+ "envelope": vault_service.get_envelope(conn, record),
+ "tier": "standard",
+ "protected": False,
+ }
+ )
continue
if resolved["status"] == "agent_delivery_ready":
current_grant = resolved["grant"]
@@ -9709,7 +9858,15 @@ def _resolve_vault_inject_delivery(engine, names: list[str], *, path: str, fmt:
break
if current_grant.get("one_shot") is True:
one_shot_grants.append(current_grant)
- secrets.append({"name": name, "key": name, "envelope": resolved["envelope"], "protected": True})
+ secrets.append(
+ {
+ "name": record,
+ "key": env_name,
+ "envelope": vault_service.get_protected_envelope(conn, record),
+ "tier": "protected",
+ "protected": True,
+ }
+ )
continue
raise TaskCliError(f"unsupported vault access status: {resolved['status']}", code="vault_access_error")
except Exception as exc:
@@ -9797,6 +9954,18 @@ def cmd_vault_run(args):
)
)
return 1
+ except vault_service.FieldsCorruptError as exc:
+ _print_task_error(TaskCliError(str(exc), code="fields_corrupt", help_command=help_command))
+ return 1
+ except vault_service.FieldNotFoundError as exc:
+ _print_task_error(TaskCliError(str(exc), code="field_not_found", help_command=help_command))
+ return 1
+ except vault_service.InvalidFieldNameError as exc:
+ _print_task_error(TaskCliError(str(exc), code="invalid_field_name", help_command=help_command))
+ return 1
+ except vault_service.FieldsNotSupportedError as exc:
+ _print_task_error(TaskCliError(str(exc), code="fields_not_supported", help_command=help_command))
+ return 1
except vault_service.UnsupportedProtectionError as exc:
_print_task_error(TaskCliError(str(exc), code="protected_tier_unavailable", help_command=help_command))
return 1
@@ -9814,6 +9983,7 @@ def cmd_vault_run(args):
handoff_started = False
try:
+ audit_identities = _capture_vault_delivery_identities(engine, [str(secret["name"]) for secret in secrets], one_shot_grants)
if grant is not None:
secret_env_names = {str(secret["env"]) for secret in secrets if secret.get("env")}
with _AgentRunOutputBridge(
@@ -9855,7 +10025,7 @@ def cmd_vault_run(args):
)
requester, delivery, _session_id = _vault_cli_delivery_context(args, mode="run", command=command_argv)
protected_names = [
- str(secret["name"])
+ _record_secret_name(secret["name"])
for secret in secrets
if secret.get("tier") == "protected" and secret.get("name")
]
@@ -9889,7 +10059,7 @@ def cmd_vault_run(args):
try:
with engine.begin() as conn:
vault_service.record_deliveries(
- conn, sorted(set(mapping.values())), requester={"source": "cli", "pid": os.getpid()}, mode="run"
+ conn, audit_identities, requester={"source": "cli", "pid": os.getpid()}, mode="run"
)
except Exception:
pass
@@ -10056,6 +10226,19 @@ def _wait_for_vault_delivery_approval(args, exc: TaskCliError, *, timeout: float
raise terminal_error
+def _vault_provision_success_usage(engine, name: str) -> str:
+ from storage import vault_service
+
+ try:
+ with engine.connect() as conn:
+ metadata = vault_service.get_secret_meta(conn, name)
+ except vault_service.SecretNotFoundError:
+ return " — check `vibe vault list` for its current availability."
+ if vault_service.has_named_field_shape(metadata):
+ return vault_service.provision_field_hint(metadata)
+ return f" — use it via: vibe vault run --env {name} -- <command>"
+
+
def cmd_vault_request(args):
from storage import vault_crypto, vault_service
@@ -10085,7 +10268,7 @@ def cmd_vault_request(args):
secret_name=name,
status="fulfilled",
request=req,
- message=f"'{name}' is already in the vault — use it via: vibe vault run --env {name} -- <command>",
+ message=f"'{name}' is already in the vault{_vault_provision_success_usage(engine, name)}",
)
return 0
wait_seconds = getattr(args, "wait", None)
@@ -10138,7 +10321,7 @@ def cmd_vault_request(args):
secret_name=name,
status="fulfilled",
request=waited,
- message=f"'{name}' is now available — use it via: vibe vault run --env {name} -- <command>",
+ message=f"'{name}' is now available{_vault_provision_success_usage(engine, name)}",
)
return 0
_print_task_error(
@@ -10511,8 +10694,10 @@ def _build_vault_fetch_request(
# and after an approval wait so a mid-wait metadata edit cannot leave a stale allowlist or auth
# injection policy in the egress frame.
with engine.connect() as conn:
- policy = vault_service.get_secret_policy(conn, name)
- meta = vault_service.get_secret_meta(conn, name)
+ record_meta = vault_service.get_secret_record_meta(conn, name)
+ secret_name = str(record_meta["name"])
+ policy = vault_service.get_secret_policy(conn, secret_name)
+ meta = record_meta
if meta.get("kind") == "keypair":
raise vault_service.KeypairNotValueDeliverableError(
f"{name} is a signing key; use vault_sign instead of value delivery"
@@ -10605,6 +10790,9 @@ def cmd_vault_fetch(args):
)
engine = _open_vault_engine()
+ with engine.connect() as conn:
+ record_meta = vault_service.get_secret_record_meta(conn, name)
+ name = str(record_meta["record_name"])
request = _build_vault_fetch_request(
engine,
name=name,
@@ -10652,6 +10840,7 @@ def cmd_vault_fetch(args):
body=body,
help_command=help_command,
)
+ audit_identity = _capture_vault_delivery_identities(engine, [name], [one_shot_grant] if one_shot_grant else [])[0]
handoff_started = True
if grant is not None:
result = api.avault_agent_deliver_fetch(
@@ -10671,7 +10860,7 @@ def cmd_vault_fetch(args):
with engine.begin() as conn:
vault_service.record_proxy_use(
conn,
- name,
+ audit_identity,
requester={"source": "cli", "pid": os.getpid()},
delivery={"host": host, "method": method, "status": status},
)
@@ -10686,6 +10875,18 @@ def cmd_vault_fetch(args):
except vault_service.KeypairNotValueDeliverableError as exc:
_print_task_error(TaskCliError(str(exc), code="keypair_not_value_deliverable", help_command=help_command))
return 1
+ except vault_service.InvalidFieldNameError as exc:
+ _print_task_error(TaskCliError(str(exc), code="invalid_field_name", help_command=help_command))
+ return 1
+ except vault_service.FieldsCorruptError as exc:
+ _print_task_error(TaskCliError(str(exc), code="fields_corrupt", help_command=help_command))
+ return 1
+ except vault_service.FieldNotFoundError as exc:
+ _print_task_error(TaskCliError(str(exc), code="field_not_found", help_command=help_command))
+ return 1
+ except vault_service.FieldsNotSupportedError as exc:
+ _print_task_error(TaskCliError(str(exc), code="fields_not_supported", help_command=help_command))
+ return 1
except vault_service.UnsupportedProtectionError as exc:
_print_task_error(TaskCliError(str(exc), code="protected_tier_unavailable", help_command=help_command))
return 1
@@ -10774,12 +10975,20 @@ def cmd_vault_inject(args):
grant = None
one_shot_grants: list[dict] = []
keys: list[str] = []
+ secrets: list[dict] = []
handoff_started = False
try:
keys = [k.strip() for k in (getattr(args, "keys", None) or "").split(",") if k.strip()]
keys = list(dict.fromkeys(keys)) # dedupe, preserve order: A,A is one entry + one audit
- if not keys:
- raise TaskCliError("--keys A,B is required", code="missing_keys", help_command=help_command)
+ env_specs = list(getattr(args, "env", None) or [])
+ tag_specs = _arg_list(args, "tag")
+ skill_specs = _arg_list(args, "skill")
+ if not keys and not env_specs and not tag_specs and not skill_specs:
+ raise TaskCliError(
+ "at least one --keys, --env NAME, --tag TAG, or --skill SKILL is required",
+ code="missing_keys",
+ help_command=help_command,
+ )
out = getattr(args, "out", None)
if not out:
raise TaskCliError("--out FILE is required", code="missing_out", help_command=help_command)
@@ -10796,7 +11005,22 @@ def cmd_vault_inject(args):
engine = _open_vault_engine()
resolved_out = _resolve_cli_output_path(str(out))
_preflight_cli_output_path(resolved_out, help_command=help_command)
- grant, one_shot_grants, secrets = _resolve_vault_inject_delivery(engine, keys, path=resolved_out, fmt=fmt, args=args)
+ selector_args = argparse.Namespace(**vars(args))
+ selector_args.env = [*env_specs, *keys]
+ mapping, source_selector = _resolve_vault_run_selectors(
+ engine,
+ selector_args,
+ help_command=help_command,
+ )
+ grant, one_shot_grants, secrets = _resolve_vault_inject_delivery(
+ engine,
+ mapping,
+ path=resolved_out,
+ fmt=fmt,
+ args=args,
+ source_selector=source_selector,
+ )
+ audit_identities = _capture_vault_delivery_identities(engine, [str(item["name"]) for item in secrets], one_shot_grants)
# avault writes the 0600 file atomically; if the path is unwritable it raises and no
# delivery is recorded.
handoff_started = True
@@ -10814,10 +11038,21 @@ def cmd_vault_inject(args):
# (callers would retry though the secrets are already written), so record best-effort.
try:
with engine.begin() as conn:
- vault_service.record_deliveries(conn, keys, requester={"source": "cli", "pid": os.getpid()}, mode=f"inject:{fmt}")
+ vault_service.record_deliveries(
+ conn,
+ audit_identities,
+ requester={"source": "cli", "pid": os.getpid()},
+ mode=f"inject:{fmt}",
+ )
except Exception:
pass
- _print_cli_payload("vault_inject", written=True, path=resolved_out, format=fmt, keys=keys)
+ _print_cli_payload(
+ "vault_inject",
+ written=True,
+ path=resolved_out,
+ format=fmt,
+ keys=[str(item["key"]) for item in secrets],
+ )
return 0
except vault_service.SecretNotFoundError as exc:
_print_task_error(TaskCliError(f"secret '{exc}' not found", code="secret_not_found", help_command=help_command))
@@ -10825,6 +11060,18 @@ def cmd_vault_inject(args):
except vault_service.KeypairNotValueDeliverableError as exc:
_print_task_error(TaskCliError(str(exc), code="keypair_not_value_deliverable", help_command=help_command))
return 1
+ except vault_service.InvalidFieldNameError as exc:
+ _print_task_error(TaskCliError(str(exc), code="invalid_field_name", help_command=help_command))
+ return 1
+ except vault_service.FieldsCorruptError as exc:
+ _print_task_error(TaskCliError(str(exc), code="fields_corrupt", help_command=help_command))
+ return 1
+ except vault_service.FieldNotFoundError as exc:
+ _print_task_error(TaskCliError(str(exc), code="field_not_found", help_command=help_command))
+ return 1
+ except vault_service.FieldsNotSupportedError as exc:
+ _print_task_error(TaskCliError(str(exc), code="fields_not_supported", help_command=help_command))
+ return 1
except vault_service.UnsupportedProtectionError as exc:
_print_task_error(TaskCliError(str(exc), code="protected_tier_unavailable", help_command=help_command))
return 1
@@ -10844,10 +11091,14 @@ def cmd_vault_inject(args):
path=resolved_out,
format=fmt,
)
+ delivery["source_selector"] = source_selector
+ delivery["protected_secret_names"] = list(
+ dict.fromkeys(_record_secret_name(item["name"]) for item in secrets)
+ )
_expire_agent_grant_after_missing(
engine,
grant["id"],
- keys,
+ [str(item["name"]) for item in secrets] or keys,
requester=requester,
delivery=delivery,
purpose="inject",
@@ -17890,7 +18141,7 @@ def build_parser():
"--env",
action="append",
metavar="NAME[,N2]|LOCAL=NAME",
- help="Inject secret NAME as env var NAME (LOCAL=NAME to rename; comma-separates several). Repeatable.",
+ help="Inject secret NAME or NAME.field as env var NAME (NAME.field defaults to NAME_FIELD; LOCAL=NAME[.field] to rename; comma-separates several). Repeatable.",
)
vault_run_parser.add_argument("--tag", action="append", metavar="TAG", help="Inject all value-deliverable secrets with this tag. Repeatable.")
vault_run_parser.add_argument("--skill", action="append", metavar="SKILL", help="Sugar for --tag skill:SKILL. Repeatable.")
@@ -17911,7 +18162,7 @@ def build_parser():
formatter_class=argparse.RawDescriptionHelpFormatter,
error_help_command="vibe vault fetch --help",
)
- vault_fetch_parser.add_argument("--auth", required=True, metavar="NAME", help="Secret to attach as the request credential")
+ vault_fetch_parser.add_argument("--auth", required=True, metavar="NAME[.field]", help="Secret record to attach as the request credential")
vault_fetch_parser.add_argument("--url", required=True, help="Target URL (host must be in the secret's allowed_hosts)")
vault_fetch_parser.add_argument("--method", default="GET", help="HTTP method (default GET)")
vault_fetch_parser.add_argument("--header", action="append", metavar="'Name: value'", help="Extra request header (repeatable)")
@@ -17932,7 +18183,7 @@ def build_parser():
formatter_class=argparse.RawDescriptionHelpFormatter,
error_help_command="vibe vault access --help",
)
- vault_access_parser.add_argument("name", help="Static secret name to request")
+ vault_access_parser.add_argument("name", help="Static secret or record reference NAME[.field] to request")
vault_access_parser.add_argument("--session-id", help="Agent Session ID. Defaults from AVIBE_SESSION_ID inside an Agent shell.")
vault_access_parser.add_argument("--skill", help="Skill requesting the secret")
vault_access_parser.add_argument("--command", dest="operation_command", help="Command or operation shown to the user")
@@ -18014,7 +18265,19 @@ def build_parser():
formatter_class=argparse.RawDescriptionHelpFormatter,
error_help_command="vibe vault inject --help",
)
- vault_inject_parser.add_argument("--keys", required=True, metavar="A,B", help="Comma-separated secret names")
+ vault_inject_parser.add_argument(
+ "--keys",
+ metavar="NAME[.field],...",
+ help="Compatibility alias for comma-separated secret record references",
+ )
+ vault_inject_parser.add_argument(
+ "--env",
+ action="append",
+ metavar="NAME[,N2]|LOCAL=NAME",
+ help="Inject secret NAME or NAME.field using the same selectors as vault run",
+ )
+ vault_inject_parser.add_argument("--tag", action="append", metavar="TAG", help="Inject all value-deliverable records from secrets with this tag. Repeatable.")
+ vault_inject_parser.add_argument("--skill", action="append", metavar="SKILL", help="Sugar for --tag skill:SKILL. Repeatable.")
vault_inject_parser.add_argument("--out", required=True, metavar="FILE", help="Output file (written 0600)")
vault_inject_parser.add_argument("--format", default="dotenv", choices=["dotenv", "json", "yaml", "toml"], help="Output format (default dotenv)")
_add_json_noop(vault_inject_parser)
diff --git a/vibe/ui_server.py b/vibe/ui_server.py
index b93cb0de6..6a3d81ebb 100644
--- a/vibe/ui_server.py
+++ b/vibe/ui_server.py
@@ -5859,7 +5859,13 @@ def vault_secrets_post():
from vibe import api
try:
- return jsonify(api.create_vault_secret(request.json or {}, origin=_vault_sandbox_webauthn_origin()))
+ return jsonify(
+ api.create_vault_secret(
+ request.json or {},
+ origin=_vault_sandbox_webauthn_origin(),
+ user_context=getattr(g, "authorization_context", None),
+ )
+ )
except ValueError as exc:
return _vault_error_response(exc)
@@ -5869,11 +5875,68 @@ def vault_secret_patch(name):
from vibe import api
try:
- return jsonify(api.update_vault_secret(name, request.json or {}))
+ return jsonify(
+ api.update_vault_secret(
+ name,
+ request.json or {},
+ user_context=getattr(g, "authorization_context", None),
+ )
+ )
except ValueError as exc:
return _vault_error_response(exc)
[email protected]("/api/vault/secrets/{name}/fields/{field}", include_in_schema=False)
+async def vault_secret_field_put(
+ name: str,
+ field: str,
+ starlette_request: FastAPIRequest,
+):
+ async def handler():
+ from vibe import api
+
+ try:
+ payload = request.json if isinstance(request.json, dict) else {}
+ return jsonify(
+ await asyncio.to_thread(
+ api.update_vault_secret_field,
+ name,
+ field,
+ payload,
+ user_context=getattr(g, "authorization_context", None),
+ )
+ )
+ except ValueError as exc:
+ return _vault_error_response(exc)
+
+ return await _dispatch_native_ui_request(starlette_request, handler)
+
+
[email protected]("/api/vault/secrets/{name}/fields/{field}", include_in_schema=False)
+async def vault_secret_field_delete(
+ name: str,
+ field: str,
+ starlette_request: FastAPIRequest,
+):
+ async def handler():
+ from vibe import api
+
+ try:
+ return jsonify(
+ await asyncio.to_thread(
+ api.delete_vault_secret_field,
+ name,
+ field,
+ request.json,
+ user_context=getattr(g, "authorization_context", None),
+ )
+ )
+ except ValueError as exc:
+ return _vault_error_response(exc)
+
+ return await _dispatch_native_ui_request(starlette_request, handler)
+
+
@app.route("/api/vault/secrets/<name>", methods=["DELETE"])
def vault_secret_delete(name):
from vibe import api
@@ -5889,7 +5952,13 @@ def vault_secret_reveal_context_post(name):
from vibe import api
try:
- return jsonify(api.create_vault_reveal_context(name, request.json or {}))
+ return jsonify(
+ api.create_vault_reveal_context(
+ name,
+ request.json or {},
+ user_context=getattr(g, "authorization_context", None),
+ )
+ )
except ValueError as exc:
return _vault_error_response(exc)
@@ -5906,7 +5975,15 @@ def vault_requests_get():
limit = int(request.args.get("limit") or 100)
except ValueError:
limit = 100
- return jsonify(api.get_vault_requests(status=status, request_type=req_type, limit=limit, session=session))
+ return jsonify(
+ api.get_vault_requests(
+ status=status,
+ request_type=req_type,
+ limit=limit,
+ session=session,
+ user_context=getattr(g, "authorization_context", None),
+ )
+ )
@app.route("/api/vault/requests/<request_id>", methods=["GET"])
@@ -5915,7 +5992,13 @@ def vault_request_get(request_id):
from storage import vault_service
try:
- return jsonify(api.get_vault_request(request_id, audience=vault_service.REQUEST_AUDIENCE_UI))
+ return jsonify(
+ api.get_vault_request(
+ request_id,
+ audience=vault_service.REQUEST_AUDIENCE_UI,
+ user_context=getattr(g, "authorization_context", None),
+ )
+ )
except ValueError as exc:
return _vault_error_response(exc)
@@ -5945,7 +6028,12 @@ def vault_access_request_post():
from vibe import api
try:
- return jsonify(api.request_vault_access(request.json or {}))
+ return jsonify(
+ api.request_vault_access(
+ request.json or {},
+ user_context=getattr(g, "authorization_context", None),
+ )
+ )
except ValueError as exc:
return _vault_error_response(exc)
@@ -5955,7 +6043,12 @@ def vault_sign_request_post():
from vibe import api
try:
- return jsonify(api.request_vault_sign(request.json or {}))
+ return jsonify(
+ api.request_vault_sign(
+ request.json or {},
+ user_context=getattr(g, "authorization_context", None),
+ )
+ )
except ValueError as exc:
return _vault_error_response(exc)