Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
Merge branch 'main' into AGE2-116
Scott Wilsoncec6fa2b3380
diff --cc .infisicalignoreindex 69bfe11111,69bfe11111..1726719b5d--- a/.infisicalignore+++ b/.infisicalignore@@@ -70,3 -70,3 +70,5 @@@ backend/src/services/pki-sync/gcp-certibackend/src/services/certificate-v3/certificate-renewal-fns.test.ts:private-key:167backend/e2e-test/routes/v1/oauth-token-exchange.spec.ts:generic-api-key:216backend/src/ee/services/audit-log-stream/splunk/splunk-provider-schemas.test.ts:generic-api-key:7++frontend/src/hooks/api/agentVault/sessionLogDecrypt.test.ts:generic-api-key:161++docs/documentation/platform/secret-scanning/scan-locally.mdx:generic-api-key:65diff --cc backend/e2e-test/routes/v1/agent-vault.spec.tsindex 72fa0ad730,61ba9413c5..e7a14107ab--- a/backend/e2e-test/routes/v1/agent-vault.spec.ts+++ b/backend/e2e-test/routes/v1/agent-vault.spec.ts@@@ -1,38 -1,29 +1,41 @@@import crypto from "node:crypto";+import * as x509 from "@peculiar/x509";+ import { createAwsAppConnection, deleteAwsAppConnection } from "e2e-test/testUtils/app-connections";import { AccessScope, ActionProjectType, OrgMembershipRole, ProjectMembershipRole, ProjectType } from "@app/db/schemas";import { seedData1 } from "@app/db/seed-data";- import { agentVaultAccessBundleDALFactory } from "@app/ee/services/agent-vault-access-bundle/agent-vault-access-bundle-dal";import { agentVaultServiceCustomHeaderDALFactory } from "@app/ee/services/agent-vault-access-bundle/agent-vault-service-custom-header-dal";import { agentVaultServiceSubstitutionDALFactory } from "@app/ee/services/agent-vault-access-bundle/agent-vault-service-substitution-dal";+import { agentVaultVariableDALFactory } from "@app/ee/services/agent-vault-access-bundle/agent-vault-variable-dal";import { agentVaultProxyDALFactory } from "@app/ee/services/agent-vault-proxy/agent-vault-proxy-dal";- import { agentVaultProxyServiceFactory } from "@app/ee/services/agent-vault-proxy/agent-vault-proxy-service";+ import {+ AGENT_VAULT_MAX_PROXIES_PER_ORG,+ agentVaultProxyServiceFactory+ } from "@app/ee/services/agent-vault-proxy/agent-vault-proxy-service";import { agentVaultResolveDALFactory } from "@app/ee/services/agent-vault-proxy/agent-vault-resolve-dal";- import { agentVaultSessionAccessBundleDALFactory } from "@app/ee/services/agent-vault-session/agent-vault-session-access-bundle-dal";import { agentVaultSessionDALFactory } from "@app/ee/services/agent-vault-session/agent-vault-session-dal";- import { agentVaultSessionServiceFactory } from "@app/ee/services/agent-vault-session/agent-vault-session-service";+ import { agentVaultSessionLogConfigDALFactory } from "@app/ee/services/agent-vault-session-log/agent-vault-session-log-config-dal";import { groupDALFactory } from "@app/ee/services/group/group-dal";+import { isHsmActiveAndEnabled } from "@app/ee/services/hsm/hsm-fns";import { permissionDALFactory } from "@app/ee/services/permission/permission-dal";import { permissionServiceFactory } from "@app/ee/services/permission/permission-service";+import { ResourceAuthMethodType } from "@app/ee/services/resource-auth-method/resource-auth-method-fns";import { KeyStorePrefixes, TKeyStoreFactory } from "@app/keystore/keystore";+import { getConfig, initEnvConfig } from "@app/lib/config/env";import { UnauthorizedError } from "@app/lib/errors";-import { initLogger } from "@app/lib/logger";+import { initLogger, logger } from "@app/lib/logger";import { additionalPrivilegeDALFactory } from "@app/services/additional-privilege/additional-privilege-dal";+ import { AppConnection } from "@app/services/app-connection/app-connection-enums";import { ActorType } from "@app/services/auth/auth-type";import { identityDALFactory } from "@app/services/identity/identity-dal";+import { internalKmsDALFactory } from "@app/services/kms/internal-kms-dal";+import { internalKmsKeyVersionDALFactory } from "@app/services/kms/internal-kms-key-version-dal";+import { kmsKekHistoryDALFactory } from "@app/services/kms/kms-kek-history-dal";+import { kmskeyDALFactory } from "@app/services/kms/kms-key-dal";+import { kmsLegacyEncryptionKeyDALFactory } from "@app/services/kms/kms-legacy-encryption-key-dal";+import { kmsServiceFactory, TKmsServiceFactory } from "@app/services/kms/kms-service";+import { KmsDataKey } from "@app/services/kms/kms-types";import { usageCounterDALFactory } from "@app/services/license-client/usage/usage-counter-dal";import { membershipDALFactory } from "@app/services/membership/membership-dal";import { orgDALFactory } from "@app/services/org/org-dal";@@@ -2262,8 -1802,8 +2536,9 @@@ describe("Agent Vault V1 Router", asynagentVaultResolveDAL: agentVaultResolveDALFactory(testDb),agentVaultServiceCustomHeaderDAL: agentVaultServiceCustomHeaderDALFactory(testDb),agentVaultServiceSubstitutionDAL: agentVaultServiceSubstitutionDALFactory(testDb),+ agentVaultVariableDAL: agentVaultVariableDALFactory(testDb),agentVaultSessionDAL: agentVaultSessionDALFactory(testDb),+ agentVaultSessionLogConfigDAL: agentVaultSessionLogConfigDALFactory(testDb),membershipDAL: membershipDALFactory(testDb),orgDAL: orgDALFactory(testDb),permissionService: buildPermissionService(),@@@ -2304,8 -1932,8 +2667,9 @@@agentVaultResolveDAL: agentVaultResolveDALFactory(testDb),agentVaultServiceCustomHeaderDAL: agentVaultServiceCustomHeaderDALFactory(testDb),agentVaultServiceSubstitutionDAL: agentVaultServiceSubstitutionDALFactory(testDb),+ agentVaultVariableDAL: agentVaultVariableDALFactory(testDb),agentVaultSessionDAL: agentVaultSessionDALFactory(testDb),+ agentVaultSessionLogConfigDAL: agentVaultSessionLogConfigDALFactory(testDb),membershipDAL: membershipDALFactory(testDb),orgDAL: orgDALFactory(testDb),permissionService: buildPermissionService(),@@@ -2458,8 -2098,8 +2834,9 @@@agentVaultResolveDAL: agentVaultResolveDALFactory(testDb),agentVaultServiceCustomHeaderDAL: agentVaultServiceCustomHeaderDALFactory(testDb),agentVaultServiceSubstitutionDAL: agentVaultServiceSubstitutionDALFactory(testDb),+ agentVaultVariableDAL: agentVaultVariableDALFactory(testDb),agentVaultSessionDAL: agentVaultSessionDALFactory(testDb),+ agentVaultSessionLogConfigDAL: agentVaultSessionLogConfigDALFactory(testDb),membershipDAL: membershipDALFactory(testDb),orgDAL: orgDALFactory(testDb),permissionService: buildPermissionService(),@@@ -3126,8 -2729,8 +3466,9 @@@agentVaultResolveDAL: agentVaultResolveDALFactory(testDb),agentVaultServiceCustomHeaderDAL: agentVaultServiceCustomHeaderDALFactory(testDb),agentVaultServiceSubstitutionDAL: agentVaultServiceSubstitutionDALFactory(testDb),+ agentVaultVariableDAL: agentVaultVariableDALFactory(testDb),agentVaultSessionDAL: agentVaultSessionDALFactory(testDb),+ agentVaultSessionLogConfigDAL: agentVaultSessionLogConfigDALFactory(testDb),membershipDAL: membershipDALFactory(testDb),orgDAL: orgDALFactory(testDb),permissionService: buildPermissionService(),@@@ -3218,8 -2827,8 +3565,9 @@@agentVaultResolveDAL: agentVaultResolveDALFactory(testDb),agentVaultServiceCustomHeaderDAL: agentVaultServiceCustomHeaderDALFactory(testDb),agentVaultServiceSubstitutionDAL: agentVaultServiceSubstitutionDALFactory(testDb),+ agentVaultVariableDAL: agentVaultVariableDALFactory(testDb),agentVaultSessionDAL: agentVaultSessionDALFactory(testDb),+ agentVaultSessionLogConfigDAL: agentVaultSessionLogConfigDALFactory(testDb),membershipDAL: membershipDALFactory(testDb),orgDAL: orgDALFactory(testDb),permissionService: buildPermissionService(),diff --cc backend/src/db/schemas/index.tsindex 4365cdad3d,212f1056c9..9b4cb74e4d--- a/backend/src/db/schemas/index.ts+++ b/backend/src/db/schemas/index.ts@@@ -8,11 -8,11 +8,13 @@@ export * from "./agent-vault-access-bunexport * from "./agent-vault-proxies";export * from "./agent-vault-service-custom-headers";export * from "./agent-vault-service-substitutions";+export * from "./agent-vault-service-variable-references";export * from "./agent-vault-services";export * from "./agent-vault-session-access-bundles";+ export * from "./agent-vault-session-log-chunks";+ export * from "./agent-vault-session-log-configs";export * from "./agent-vault-sessions";+export * from "./agent-vault-variables";export * from "./alert-channel-memberships";export * from "./alert-channel-recipients";export * from "./alert-channels";diff --cc backend/src/ee/routes/v1/agent-vault-routers/agent-vault-schemas.tsindex b152afb7d1,8e74368f23..0d4e566219--- a/backend/src/ee/routes/v1/agent-vault-routers/agent-vault-schemas.ts+++ b/backend/src/ee/routes/v1/agent-vault-routers/agent-vault-schemas.ts@@@ -9,13 -9,11 +9,13 @@@ importAgentVaultCredentialType,AgentVaultHttpMethod,AgentVaultMemberType,- AgentVaultSubstitutionSurface+ AgentVaultSubstitutionSurface,+ AgentVaultVariableReferenceField} from "@app/ee/services/agent-vault/agent-vault-enums";- import { hostPatternSchema } from "@app/ee/services/agent-vault/agent-vault-host-pattern";- import { agentVaultPathPrefixListSchema } from "@app/ee/services/agent-vault/agent-vault-path-prefix";+ import { hostPatternSchema } from "@app/ee/services/agent-vault/agent-vault-host-pattern-fns";+ import { agentVaultPathPrefixListSchema } from "@app/ee/services/agent-vault/agent-vault-path-prefix-schemas";import {+ acceptsVariableReferences,addDuplicateCustomHeaderNameIssues,addDuplicatePlaceholderIssues,AGENT_VAULT_MAX_CUSTOM_HEADERS,diff --cc backend/src/ee/services/agent-vault-access-bundle/agent-vault-access-bundle-types.tsindex 18894acdf1,6c7a1ccfbb..1e3a3fca09--- a/backend/src/ee/services/agent-vault-access-bundle/agent-vault-access-bundle-types.ts+++ b/backend/src/ee/services/agent-vault-access-bundle/agent-vault-access-bundle-types.ts@@@ -22,13 -22,7 +23,13 @@@ export type TAgentVaultCredentialSummar| { type: AgentVaultCredentialType.Basic }| { type: AgentVaultCredentialType.Passthrough };+export type TAgentVaultVariableReferenceSummary = { variableId: string; key: string } & (+ | { field: AgentVaultVariableReferenceField.CredentialValue | AgentVaultVariableReferenceField.CredentialUsername }+ | { field: AgentVaultVariableReferenceField.CustomHeader; customHeaderId: string }+ | { field: AgentVaultVariableReferenceField.Substitution; substitutionId: string }+);+- export type TAgentVaultProjectScoped = { projectId: string; ctx: TAgentVaultActorContext };+ export type TAgentVaultProjectScoped = { projectId: string; ctx: TGenericPermission };export type TListAccessBundlesDTO = TAgentVaultProjectScoped & {search?: string;diff --cc backend/src/ee/services/agent-vault-proxy/agent-vault-proxy-service.tsindex e798650855,372d440f03..8f4aa8572c--- a/backend/src/ee/services/agent-vault-proxy/agent-vault-proxy-service.ts+++ b/backend/src/ee/services/agent-vault-proxy/agent-vault-proxy-service.ts@@@ -24,16 -25,17 +25,23 @@@ import { TOrgDALFactory } from "@app/seimport { isUniqueViolation } from "../agent-vault/agent-vault-db-error-fns";import { AgentVaultCredentialType, AgentVaultTrafficPolicy } from "../agent-vault/agent-vault-enums";import { findReachableAccessBundleIds, liveGroupIdsFrom } from "../agent-vault/agent-vault-permission";+import {+ AGENT_VAULT_EXPANDED_FIELD_MAX_LENGTH,+ expandStoredVariableReferences,+ findStoredVariableIds+} from "../agent-vault/agent-vault-variable-fns";import { TAgentVaultServiceCustomHeaderDALFactory } from "../agent-vault-access-bundle/agent-vault-service-custom-header-dal";import { TAgentVaultServiceSubstitutionDALFactory } from "../agent-vault-access-bundle/agent-vault-service-substitution-dal";+import { TAgentVaultVariableDALFactory } from "../agent-vault-access-bundle/agent-vault-variable-dal";import { TAgentVaultSessionDALFactory } from "../agent-vault-session/agent-vault-session-dal";import { hashSessionToken } from "../agent-vault-session/agent-vault-session-fns";+ import { TAgentVaultSessionLogConfigDALFactory } from "../agent-vault-session-log/agent-vault-session-log-config-dal";+ import {+ getSessionLogEntitlement,+ isSessionLogIngestEnabled,+ TSessionLogLicenseService+ } from "../agent-vault-session-log/agent-vault-session-log-fns";+ import { openSessionLogKey } from "../agent-vault-session-log/agent-vault-session-log-secrets";import { RESOURCE_TYPE_AGENT_VAULT_PROXY } from "../resource-auth-method/resource-auth-method-fns";import { TResourceAuthMethodServiceFactory } from "../resource-auth-method/resource-auth-method-service";import { parseRootCaCertificate } from "./agent-vault-ca-fns";@@@ -60,8 -64,8 +70,9 @@@ type TAgentVaultProxyServiceFactoryDepagentVaultResolveDAL: TAgentVaultResolveDALFactory;agentVaultServiceCustomHeaderDAL: Pick<TAgentVaultServiceCustomHeaderDALFactory, "findByServiceIds">;agentVaultServiceSubstitutionDAL: Pick<TAgentVaultServiceSubstitutionDALFactory, "findByServiceIds">;+ agentVaultVariableDAL: Pick<TAgentVaultVariableDALFactory, "findValuesForResolve">;agentVaultSessionDAL: Pick<TAgentVaultSessionDALFactory, "findByTokenHash">;+ agentVaultSessionLogConfigDAL: Pick<TAgentVaultSessionLogConfigDALFactory, "findOne">;membershipDAL: Pick<TMembershipDALFactory, "findResourceMembershipsForActor">;orgDAL: Pick<TOrgDALFactory, "findEffectiveOrgMembership">;permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;@@@ -79,8 -84,8 +91,9 @@@ export const agentVaultProxyServiceFactagentVaultResolveDAL,agentVaultServiceCustomHeaderDAL,agentVaultServiceSubstitutionDAL,+ agentVaultVariableDAL,agentVaultSessionDAL,+ agentVaultSessionLogConfigDAL,membershipDAL,orgDAL,permissionService,@@@ -321,100 -336,8 +344,100 @@@return { type: "basic", username: secret.username ?? "", password: secret.password ?? "" };};+ // The ids come out of the decrypted fields rather than the reference rows, so a service saved mid-poll can+ // never leave the two describing different versions of a field. An id with nothing behind it stays as text,+ // and so does a field its variables would fill past the length cap: dropping the service instead would also+ // drop its method and path restrictions.+ const $expandVariableReferences = async ({+ sessionId,+ services,+ accessBundleIdOf,+ decryptValue+ }: {+ sessionId: string;+ services: TResolvedService[];+ accessBundleIdOf: Map<string, string>;+ decryptValue: (encryptedValue: Buffer) => string;+ }): Promise<TResolvedService[]> => {+ const sealedTextsOf = ({ credential, customHeaders, substitutions }: TResolvedService) => [+ ...(credential.type === "bearer" ? [credential.value] : []),+ ...(credential.type === "basic" ? [credential.username, credential.password] : []),+ ...customHeaders.map((header) => header.value),+ ...substitutions.map((substitution) => substitution.value)+ ];++ const variableIds = [+ ...new Set(services.flatMap((service) => sealedTextsOf(service).flatMap(findStoredVariableIds)))+ ];+ if (!variableIds.length) return services;++ const variables = new Map(+ (+ await agentVaultVariableDAL.findValuesForResolve({+ variableIds,+ accessBundleIds: [...new Set(accessBundleIdOf.values())]+ })+ ).map((variable) => [variable.id, variable])+ );++ const opened = new Map<string, string>();+ const unresolvedServiceIds = new Set<string>();+ const oversizedServiceIds = new Set<string>();++ const expanded = services.map((service) => {+ const valueOf = (variableId: string) => {+ const variable = variables.get(variableId);+ // A stored id only ever names a variable of the service's own bundle.+ if (!variable || variable.accessBundleId !== accessBundleIdOf.get(service.id)) {+ unresolvedServiceIds.add(service.id);+ return undefined;+ }+ let value = opened.get(variableId);+ if (value === undefined) {+ value = decryptValue(variable.encryptedValue);+ opened.set(variableId, value);+ }+ return value;+ };+ const expand = (text: string) => {+ const filledIn = expandStoredVariableReferences(text, valueOf);+ if (filledIn === undefined) oversizedServiceIds.add(service.id);+ return filledIn ?? text;+ };++ let { credential } = service;+ if (credential.type === "bearer") credential = { ...credential, value: expand(credential.value) };+ if (credential.type === "basic") {+ credential = { ...credential, username: expand(credential.username), password: expand(credential.password) };+ }++ return {+ ...service,+ credential,+ customHeaders: service.customHeaders.map((header) => ({ ...header, value: expand(header.value) })),+ substitutions: service.substitutions.map((substitution) => ({+ ...substitution,+ value: expand(substitution.value)+ }))+ };+ });++ if (unresolvedServiceIds.size) {+ logger.error(+ `agentVaultResolve: stored variable reference with no variable [sessionId=${sessionId}] [serviceIds=${[...unresolvedServiceIds].join(",")}]`+ );+ }+ if (oversizedServiceIds.size) {+ logger.warn(+ `agentVaultResolve: variables fill a field past ${AGENT_VAULT_EXPANDED_FIELD_MAX_LENGTH} characters [sessionId=${sessionId}] [serviceIds=${[...oversizedServiceIds].join(",")}]`+ );+ }++ return expanded;+ };+/** The only endpoint that decrypts a credential. The proxy's JWT authorizes; the session token is a selector. */- const resolveSession = async ({ proxyId, orgId, sessionToken }: TResolveSessionDTO) => {+ const resolveSession = async ({ proxyId, orgId, sessionToken, hasSessionLogKey }: TResolveSessionDTO) => {const session = await agentVaultSessionDAL.findByTokenHash(hashSessionToken(sessionToken));if (!session) throw new NotFoundError({ message: "Session not found" });@@@ -537,13 -473,27 +573,34 @@@}))}));+ const services = await $expandVariableReferences({+ sessionId: session.id,+ services: decryptedServices,+ accessBundleIdOf: new Map(rows.map((row) => [row.id, row.accessBundleId])),+ decryptValue: $decryptValue+ });++ // A key that can't be opened turns logs off for this session instead of cutting the agent off from its services.+ const $sessionLogs = (): { enabled: boolean; sessionKey: string | null } => {+ if (!sessionLogKeyNeeded || !session.encryptedSessionLogKey) {+ return { enabled: sessionLogsEnabled, sessionKey: null };+ }+ try {+ const sessionKey = openSessionLogKey({+ sessionId: session.id,+ payload: decryptor!({ cipherTextBlob: session.encryptedSessionLogKey })+ }).toString("base64");+ return { enabled: sessionLogsEnabled, sessionKey };+ } catch (error) {+ logger.error(+ error,+ `agentVaultResolve: could not open the session log key, session logs are off for this session [sessionId=${session.id}] [proxyId=${proxyId}]`+ );+ return { enabled: false, sessionKey: null };+ }+ };+ const sessionLogs = $sessionLogs();+logger.info(`agentVaultResolve: resolved [sessionId=${session.id}] [proxyId=${proxyId}] [services=${services.length}]`);diff --cc backend/src/ee/services/agent-vault/CLAUDE.mdindex 5c807c6a4f,2c02e4d7e9..1a11d41ab7--- a/backend/src/ee/services/agent-vault/CLAUDE.md+++ b/backend/src/ee/services/agent-vault/CLAUDE.md@@@ -17,11 -17,12 +17,12 @@@ never in anything the agent holds```agent-vault/ shared: enums, host grammar, conflict detection, reachability-agent-vault-access-bundle/ bundles, services, credential encryption, grants+agent-vault-access-bundle/ bundles, services, variables, credential encryption, grantsagent-vault-member/ product membership (list, add, role, remove)- agent-vault-session/ mint, revoke, list, retention sweep+ agent-vault-session/ mint, revoke, list, getagent-vault-project/ the per-org project's lazy bootstrap and resolveragent-vault-proxy/ login (enrollment), heartbeat, resolve+ agent-vault-session-log/ storage settings, chunk ingest, playback```Routes: `ee/routes/v1/agent-vault-routers/`, prefix `/api/v1/agent-vault`. CLI: `packages/cmd/agent_vault*.go`diff --cc backend/src/server/routes/index.tsindex d263d1af23,8720b9fb93..a657f805f1--- a/backend/src/server/routes/index.ts+++ b/backend/src/server/routes/index.ts@@@ -2007,8 -2008,8 +2014,9 @@@ export const registerRoutes = asyncagentVaultResolveDAL,agentVaultServiceCustomHeaderDAL,agentVaultServiceSubstitutionDAL,+ agentVaultVariableDAL,agentVaultSessionDAL,+ agentVaultSessionLogConfigDAL,membershipDAL,orgDAL,permissionService,diff --cc docs/docs.jsonindex dd3f0e1676,16be8632fc..2c81725317--- a/docs/docs.json+++ b/docs/docs.json@@@ -798,8 -800,8 +800,9 @@@"pages": ["documentation/platform/agent-vault/access-bundles","documentation/platform/agent-vault/services",+ "documentation/platform/agent-vault/variables","documentation/platform/agent-vault/sessions",+ "documentation/platform/agent-vault/session-logs","documentation/platform/agent-vault/proxies","documentation/platform/agent-vault/access-control"]diff --cc frontend/src/components/agent-vault/service-sheet/ServiceSheet.tsxindex 52bdebec85,e18d4a479d..fe8634942e--- a/frontend/src/components/agent-vault/service-sheet/ServiceSheet.tsx+++ b/frontend/src/components/agent-vault/service-sheet/ServiceSheet.tsx@@@ -1,6 -1,7 +1,7 @@@-import { useEffect, useMemo, useRef, useState } from "react";+import { useCallback, useEffect, useMemo, useRef, useState } from "react";import { FormProvider, useForm } from "react-hook-form";import { zodResolver } from "@hookform/resolvers/zod";+ import slugify from "@sindresorhus/slugify";import axios from "axios";import { createNotification } from "@app/components/notifications";@@@ -77,42 -93,10 +101,44 @@@ type Props =onOpenChange: (isOpen: boolean) => void;accessBundleId: string;service?: TAgentVaultService | null;+ prefillHost?: string;+ onSaved?: () => void;};+const storedVariableKeys = (service?: TAgentVaultService | null) => {+ const references = service?.variableReferences;+ if (!service || !references?.length) return NO_STORED_KEYS;++ const keysWhere = (match: (reference: TAgentVaultVariableReference) => boolean) =>+ references.filter(match).map((reference) => reference.key);+ const byRow = (+ rows: { id: string }[],+ idOf: (r: TAgentVaultVariableReference) => string | null+ ) =>+ Object.fromEntries(+ rows.map((row) => [row.id, keysWhere((reference) => idOf(reference) === row.id)])+ );++ return {+ secret: keysWhere(+ (reference) => reference.field === AgentVaultVariableReferenceField.CredentialValue+ ),+ username: keysWhere(+ (reference) => reference.field === AgentVaultVariableReferenceField.CredentialUsername+ ),+ customHeaders: byRow(service.customHeaders, (reference) =>+ reference.field === AgentVaultVariableReferenceField.CustomHeader+ ? reference.customHeaderId+ : null+ ),+ substitutions: byRow(service.substitutions, (reference) =>+ reference.field === AgentVaultVariableReferenceField.Substitution+ ? reference.substitutionId+ : null+ )+ };+};+// Long enough for the advanced section to open and settle. There is no event to wait on: the section// is a Radix accordion, whose content is unmounted while closed, so the control cannot be measured// until after it mounts and takes its height.diff --cc frontend/src/hooks/api/agentVault/enums.tsindex 2d18e13235,4f35bcc08f..75d997b948--- a/frontend/src/hooks/api/agentVault/enums.ts+++ b/frontend/src/hooks/api/agentVault/enums.ts@@@ -43,10 -43,9 +43,17 @@@ export enum AgentVaultSessionScopeAll = "all"}+ export enum AgentVaultSessionLogDecision {+ Brokered = "brokered",+ Passthrough = "passthrough",+ Blocked = "blocked",+ Error = "error"+ }+++/** Which value of a service uses a variable. A basic credential's password is its credential-value. */+export enum AgentVaultVariableReferenceField {+ CredentialValue = "credential-value",+ CredentialUsername = "credential-username",+ CustomHeader = "custom-header",+ Substitution = "substitution"+}diff --cc frontend/src/hooks/api/agentVault/mutations.tsxindex a227e6b142,6c7153019a..3ce976de4e--- a/frontend/src/hooks/api/agentVault/mutations.tsx+++ b/frontend/src/hooks/api/agentVault/mutations.tsx@@@ -18,16 -18,14 +18,18 @@@ importTAgentVaultProxy,TAgentVaultProxySettingsDTO,TAgentVaultService,+ TAgentVaultSessionLogSettings,+ TAgentVaultVariable,+ TAgentVaultVariableRef,TAgentVaultWrittenMember,TCreateAgentVaultAccessBundleDTO,TCreateAgentVaultServiceDTO,TCreateAgentVaultSessionDTO,+ TCreateAgentVaultVariableDTO,TUpdateAgentVaultAccessBundleDTO,TUpdateAgentVaultServiceDTO,- TUpdateAgentVaultSessionLogSettingsDTO++ TUpdateAgentVaultSessionLogSettingsDTO,+ TUpdateAgentVaultVariableDTO} from "./types";export const useCreateAgentVaultAccessBundle = () => {@@@ -364,74 -362,28 +366,100 @@@ export const useRevokeAgentVaultMember});};+ export const useUpdateAgentVaultSessionLogSettings = () => {+ const { currentOrg } = useOrganization();+ const queryClient = useQueryClient();++ return useMutation({+ mutationFn: async (params: TUpdateAgentVaultSessionLogSettingsDTO) => {+ const { data } = await apiRequest.patch<{ settings: TAgentVaultSessionLogSettings }>(+ "/api/v1/agent-vault/settings/session-logs",+ params+ );+ return data.settings;+ },+ onSuccess: (settings) => {+ queryClient.setQueryData(agentVaultKeys.sessionLogSettings(currentOrg.id), settings);+ // Reset, not invalidate: the cached result may be for the previous bucket.+ queryClient.resetQueries({+ queryKey: agentVaultKeys.sessionLogCorsProbe(currentOrg.id)+ });+ queryClient.invalidateQueries({+ queryKey: agentVaultKeys.sessionLogHealth(currentOrg.id)+ });+ queryClient.invalidateQueries({ queryKey: agentVaultKeys.sessions(currentOrg.id) });+ }+ });+ };+++// The bundle key covers its variables too, and a rename changes the keys each service reports.+const invalidateVariables = (+ queryClient: ReturnType<typeof useQueryClient>,+ orgId: string,+ accessBundleId: string+) =>+ queryClient.invalidateQueries({ queryKey: agentVaultKeys.accessBundle(orgId, accessBundleId) });++export const useCreateAgentVaultVariable = () => {+ const { currentOrg } = useOrganization();+ const queryClient = useQueryClient();+ return useMutation({+ mutationFn: async ({ accessBundleId, ...params }: TCreateAgentVaultVariableDTO) => {+ const { data } = await apiRequest.post<{ variable: TAgentVaultVariable }>(+ `/api/v1/agent-vault/access-bundles/${accessBundleId}/variables`,+ params+ );+ return data.variable;+ },+ onSuccess: (variable, { accessBundleId }) => {+ // Listed before the refetch lands, so a reference to it that was just inserted reads as known.+ queryClient.setQueryData<TAgentVaultVariable[]>(+ agentVaultKeys.accessBundleVariables(currentOrg.id, accessBundleId),+ (prev) => (prev ? [...prev, variable].sort((a, b) => a.key.localeCompare(b.key)) : prev)+ );+ return invalidateVariables(queryClient, currentOrg.id, accessBundleId);+ }+ });+};++export const useUpdateAgentVaultVariable = () => {+ const { currentOrg } = useOrganization();+ const queryClient = useQueryClient();+ return useMutation({+ mutationFn: async ({ accessBundleId, variableId, ...params }: TUpdateAgentVaultVariableDTO) => {+ const { data } = await apiRequest.patch<{ variable: TAgentVaultVariable }>(+ `/api/v1/agent-vault/access-bundles/${accessBundleId}/variables/${variableId}`,+ params+ );+ return data.variable;+ },+ onSuccess: (_, { accessBundleId }) =>+ invalidateVariables(queryClient, currentOrg.id, accessBundleId)+ });+};++export const useDeleteAgentVaultVariable = () => {+ const { currentOrg } = useOrganization();+ const queryClient = useQueryClient();+ return useMutation({+ mutationFn: async ({ accessBundleId, variableId }: TAgentVaultVariableRef) => {+ const { data } = await apiRequest.delete<{ variable: TAgentVaultVariable }>(+ `/api/v1/agent-vault/access-bundles/${accessBundleId}/variables/${variableId}`+ );+ return data.variable;+ },+ onSuccess: (_, { accessBundleId }) =>+ invalidateVariables(queryClient, currentOrg.id, accessBundleId)+ });+};++// A mutation rather than a query, so a revealed value never enters the query cache.+export const useRevealAgentVaultVariableValue = () =>+ useMutation({+ mutationFn: async ({ accessBundleId, variableId }: TAgentVaultVariableRef) => {+ const { data } = await apiRequest.get<{ value: string }>(+ `/api/v1/agent-vault/access-bundles/${accessBundleId}/variables/${variableId}/value`+ );+ return data.value;+ }+ });diff --cc frontend/src/hooks/api/agentVault/queries.tsxindex 4f4bce47e0,0d33f9163e..cab6efb89c--- a/frontend/src/hooks/api/agentVault/queries.tsx+++ b/frontend/src/hooks/api/agentVault/queries.tsx@@@ -13,7 -21,12 +21,13 @@@ importTAgentVaultProductMemberOf,TAgentVaultProxy,TAgentVaultSession,+ TAgentVaultSessionLogCorsProbe,+ TAgentVaultSessionLogHealth,+ TAgentVaultSessionLogHistoryPage,+ TAgentVaultSessionLogReadCheck,+ TAgentVaultSessionLogSettings,+ TAgentVaultSessionLogTailPage,+ TAgentVaultVariable,TListAgentVaultAccessBundlesDTO,TListAgentVaultMembersDTO,TListAgentVaultProxiesDTO,@@@ -220,17 -254,174 +257,189 @@@ export const useListAgentVaultProxies});};+ export const useGetAgentVaultSessionLogSettings = (enabled = true) => {+ const { currentOrg } = useOrganization();++ return useQuery({+ queryKey: agentVaultKeys.sessionLogSettings(currentOrg.id),+ queryFn: async () => {+ const { data } = await apiRequest.get<{ settings: TAgentVaultSessionLogSettings }>(+ "/api/v1/agent-vault/settings/session-logs"+ );+ return data.settings;+ },+ enabled+ });+ };++ export const useGetAgentVaultSessionLogHealth = (enabled = true) => {+ const { currentOrg } = useOrganization();++ return useQuery({+ queryKey: agentVaultKeys.sessionLogHealth(currentOrg.id),+ queryFn: async () => {+ const { data } = await apiRequest.get<{ health: TAgentVaultSessionLogHealth }>(+ "/api/v1/agent-vault/settings/session-logs/health"+ );+ return data.health;+ },+ enabled+ });+ };++ export const fetchAgentVaultSessionLogReadAccess =+ async (): Promise<TAgentVaultSessionLogReadCheck | null> => {+ const { data } = await apiRequest.get<{ probe: TAgentVaultSessionLogCorsProbe }>(+ "/api/v1/agent-vault/settings/session-logs/cors-probe"+ );+ if (!data.probe) return null;+ const { host, origin } = new URL(data.probe.url);+ let isHostBlocked = false;+ const onViolation = (event: SecurityPolicyViolationEvent) => {+ if (event.effectiveDirective === "connect-src" && event.blockedURI.startsWith(origin)) {+ isHostBlocked = true;+ }+ };+ document.addEventListener("securitypolicyviolation", onViolation);+ // The probed object never exists. S3 adds CORS headers to its 404 and to a 403 alike, so fetch+ // rejects only when the rule is missing or this page's CSP blocks the host, and a 403 means the+ // connection may not read the bucket.+ try {+ const res = await fetch(data.probe.url, { mode: "cors", credentials: "omit" });+ return { status: res.status === 403 ? "access-denied" : "readable", host };+ } catch {+ // The violation event is queued as a task, so it can land after fetch has already rejected.+ await new Promise((resolve) => {+ setTimeout(resolve, 0);+ });+ return { status: isHostBlocked ? "host-blocked" : "cors-missing", host };+ } finally {+ document.removeEventListener("securitypolicyviolation", onViolation);+ }+ };++ export const useGetAgentVaultSessionLogCorsProbe = (enabled = true) => {+ const { currentOrg } = useOrganization();++ return useQuery({+ queryKey: agentVaultKeys.sessionLogCorsProbe(currentOrg.id),+ queryFn: fetchAgentVaultSessionLogReadAccess,+ enabled,+ retry: false+ });+ };++ export const useGetAgentVaultSession = (sessionId: string | undefined, enabled = true) => {+ const { currentOrg } = useOrganization();++ return useQuery({+ queryKey: agentVaultKeys.session(currentOrg.id, sessionId ?? ""),+ queryFn: async () => {+ const { data } = await apiRequest.get<{ session: TAgentVaultSession }>(+ `/api/v1/agent-vault/sessions/${sessionId}`+ );+ return data.session;+ },+ enabled: enabled && Boolean(sessionId),+ refetchInterval: 30_000,+ retry: false+ });+ };++ export const useGetAgentVaultSessionLogs = (+ sessionId: string | undefined,+ {+ enabled = true,+ isLive = false,+ from,+ to+ }: { enabled?: boolean; isLive?: boolean; from?: Date; to?: Date } = {}+ ) => {+ const { currentOrg } = useOrganization();+ const queryClient = useQueryClient();++ const range = { from: from?.toISOString(), to: to?.toISOString() };+ const url = `/api/v1/agent-vault/sessions/${sessionId}/logs`;+ const tailUrl = `${url}/tail`;++ // Reset during render so neither query fetches a new session into the old one's cache.+ const chunkCache = useRef<TAgentVaultSessionLogChunkCache | null>(null);+ if (!chunkCache.current || chunkCache.current.sessionId !== sessionId) {+ chunkCache.current = createSessionLogChunkCache(sessionId ?? "");+ }++ const history = useInfiniteQuery({+ queryKey: agentVaultKeys.sessionLogs(currentOrg.id, sessionId ?? "", range),+ enabled: enabled && Boolean(sessionId),+ initialPageParam: undefined as string | undefined,+ queryFn: async ({ pageParam, signal }) => {+ const cache = chunkCache.current as TAgentVaultSessionLogChunkCache;+ const { data } = await apiRequest.get<TAgentVaultSessionLogHistoryPage>(url, {+ params: {+ limit: SESSION_LOG_PAGE_RECORDS,+ ...(pageParam ? { cursor: pageParam } : {}),+ ...(range.from ? { from: range.from } : {}),+ ...(range.to ? { to: range.to } : {})+ },+ signal+ });+ return decryptSessionLogPage(data, cache, signal);+ },+ getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,+ placeholderData: (prev, prevQuery) =>+ sessionId && prevQuery?.queryKey.includes(sessionId) ? prev : undefined,+ staleTime: 0,+ // Pages hold decrypted plaintext, so drop them as soon as nothing observes them.+ gcTime: 0+ });++ const liveFrom = history.isPlaceholderData ? undefined : history.data?.pages[0]?.liveCursor;+ const isRecordable = history.data?.pages[0]?.sessionLogs.isRecordable !== false;+ const liveKey = agentVaultKeys.sessionLogsLive(currentOrg.id, sessionId ?? "", range);++ const live = useQuery({+ queryKey: liveKey,+ enabled: enabled && isLive && isRecordable && Boolean(sessionId) && Boolean(liveFrom),+ queryFn: async ({ signal }) => {+ const cache = chunkCache.current as TAgentVaultSessionLogChunkCache;+ let arrived =+ queryClient.getQueryData<TAgentVaultDecryptedSessionLogPage<TAgentVaultSessionLogTailPage>>(+ liveKey+ );+ let cursor = arrived?.nextCursor ?? liveFrom;+ let hasMore = true;+ for (let read = 0; hasMore && read < SESSION_LOG_LIVE_MAX_READS; read += 1) {+ // eslint-disable-next-line no-await-in-loop+ const { data } = await apiRequest.get<TAgentVaultSessionLogTailPage>(tailUrl, {+ params: { limit: SESSION_LOG_LIVE_RECORDS, cursor },+ signal+ });+ // eslint-disable-next-line no-await-in-loop+ arrived = mergeSessionLogPages(arrived, await decryptSessionLogPage(data, cache, signal));+ cursor = data.nextCursor;+ ({ hasMore } = data);+ }+ return arrived as TAgentVaultDecryptedSessionLogPage<TAgentVaultSessionLogTailPage>;+ },+ refetchInterval: AGENT_VAULT_SESSION_LOG_LIVE_POLL_MS,+ staleTime: 0,+ gcTime: 0+ });++ return { history, live, arrived: live.data };+ };+++export const useListAgentVaultVariables = (accessBundleId: string, enabled = true) => {+ const { currentOrg } = useOrganization();++ return useQuery({+ queryKey: agentVaultKeys.accessBundleVariables(currentOrg.id, accessBundleId),+ queryFn: async () => {+ const { data } = await apiRequest.get<{ variables: TAgentVaultVariable[] }>(+ `/api/v1/agent-vault/access-bundles/${accessBundleId}/variables`+ );+ return data.variables;+ },+ enabled: enabled && Boolean(accessBundleId)+ });+};diff --cc frontend/src/hooks/api/agentVault/types.tsindex e1c11ff6de,202e76e091..ab3a315d1f--- a/frontend/src/hooks/api/agentVault/types.ts+++ b/frontend/src/hooks/api/agentVault/types.ts@@@ -296,32 -287,134 +303,164 @@@ export type TAgentVaultProxySettingsDTpollInterval?: number;};+ export type TAgentVaultSessionLogSettings = {+ enabled: boolean;+ appConnectionId: string | null;+ bucket: string | null;+ region: string | null;+ keyPrefix: string | null;+ };++ export type TAgentVaultSessionLogHealth = {+ isStorageFull: boolean;+ connectionError: string | null;+ };++ export type TAgentVaultSessionLogCorsProbe = {+ url: string;+ expiresInSeconds: number;+ } | null;++ export type TAgentVaultSessionLogReadAccess =+ | "readable"+ | "cors-missing"+ | "access-denied"+ | "host-blocked";++ export type TAgentVaultSessionLogReadCheck = {+ status: TAgentVaultSessionLogReadAccess;+ host: string;+ };++ export type TUpdateAgentVaultSessionLogSettingsDTO = {+ enabled?: boolean;+ appConnectionId?: string | null;+ bucket?: string;+ region?: string;+ keyPrefix?: string;+ };++ export type TAgentVaultSessionLogChunk = {+ chunkId: string;+ proxyId: string;+ proxyName: string;+ startedAt: string;+ endedAt: string;+ firstSeq: number;+ lastSeq: number;+ recordCount: number;+ droppedCount: number;+ ciphertextBytes: number;+ iv: string;+ ciphertextSha256: string;+ presignedGetUrl: string | null;+ createdAt: string;+ };++ export type TAgentVaultSessionLog = {+ enabled: boolean;+ isRecordable: boolean;+ sessionKey: string | null;+ storageUnavailable: {+ reason: "no-connection" | "connection-unusable";+ message: string | null;+ } | null;+ };++ export type TAgentVaultSessionLogPage = {+ sessionLogs: TAgentVaultSessionLog;+ chunks: TAgentVaultSessionLogChunk[];+ };++ export type TAgentVaultSessionLogHistoryPage = TAgentVaultSessionLogPage & {+ nextCursor: string | null;+ liveCursor: string;+ };++ export type TAgentVaultSessionLogTailPage = TAgentVaultSessionLogPage & {+ nextCursor: string;+ hasMore: boolean;+ };++ export type TAgentVaultSessionLogRecord = {+ ts: string;+ seq: number;+ proxyId: string;+ method: string;+ host: string;+ port: string;+ path: string;+ status: number;+ decision: AgentVaultSessionLogDecision;+ service: string | null;+ accessBundle: string | null;+ };++ export type TAgentVaultSessionLogGapReason =+ | "fetch"+ | "missing"+ | "refused"+ | "size"+ | "altered"+ | "gcm"+ | "json"+ | "mismatch"+ | "repointed";++ export type TAgentVaultSessionLogGap = {+ chunkId: string;+ proxyId: string;+ proxyName: string;+ startedAt: string;+ reason: TAgentVaultSessionLogGapReason;+ recordCount: number;+ };++ export type TAgentVaultSessionLogDrop = {+ chunkId: string;+ proxyId: string;+ startedAt: string;+ droppedCount: number;+ };++ export type TAgentVaultDecryptedChunk = {+ records: TAgentVaultSessionLogRecord[];+ gap: TAgentVaultSessionLogGap | null;+ arrivedAt: number | null;+ };++ export type TAgentVaultDecryptedSessionLogPage<+ P extends TAgentVaultSessionLogPage = TAgentVaultSessionLogPage+ > = P & {+ decrypted: Record<string, TAgentVaultDecryptedChunk>;+ };+++export type TAgentVaultVariable = {+ id: string;+ accessBundleId: string;+ key: string;+ isSecret: boolean;+ /** Null for a secret variable, whose value comes only from the value route. */+ value: string | null;+ serviceIds: string[];+ createdAt: string;+ updatedAt: string;+};++export type TAgentVaultVariableRef = {+ accessBundleId: string;+ variableId: string;+};++export type TCreateAgentVaultVariableDTO = {+ accessBundleId: string;+ key: string;+ value: string;+ isSecret: boolean;+};++export type TUpdateAgentVaultVariableDTO = TAgentVaultVariableRef & {+ key?: string;+ value?: string;+ isSecret?: boolean;+};diff --cc frontend/src/pages/agent-vault/agent-vault-docs-urls.tsindex 84592bc894,3393f20c6b..535f814a00--- a/frontend/src/pages/agent-vault/agent-vault-docs-urls.ts+++ b/frontend/src/pages/agent-vault/agent-vault-docs-urls.ts@@@ -5,7 -5,7 +5,8 @@@ export const AgentVaultDocsUrls =quickstart: `${AGENT_VAULT_DOCS_BASE_URL}/quickstart`,accessBundles: `${AGENT_VAULT_DOCS_BASE_URL}/access-bundles`,services: `${AGENT_VAULT_DOCS_BASE_URL}/services`,+ variables: `${AGENT_VAULT_DOCS_BASE_URL}/variables`,sessions: `${AGENT_VAULT_DOCS_BASE_URL}/sessions`,- proxies: `${AGENT_VAULT_DOCS_BASE_URL}/proxies`+ proxies: `${AGENT_VAULT_DOCS_BASE_URL}/proxies`,+ sessionLogs: `${AGENT_VAULT_DOCS_BASE_URL}/session-logs`} as const;