Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

Merge branch 'main' into AGE2-116

Scott Wilsoncec6fa2b3380
diff --cc .infisicalignore
index 69bfe11111,69bfe11111..1726719b5d
--- a/.infisicalignore
+++ b/.infisicalignore
@@@ -70,3 -70,3 +70,5 @@@ backend/src/services/pki-sync/gcp-certi
backend/src/services/certificate-v3/certificate-renewal-fns.test.ts:private-key:167
backend/e2e-test/routes/v1/oauth-token-exchange.spec.ts:generic-api-key:216
backend/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:65
diff --cc backend/e2e-test/routes/v1/agent-vault.spec.ts
index 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", asyn
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(),
@@@ -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.ts
index 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-bun
export * 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.ts
index 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 @@@ import
AgentVaultCredentialType,
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.ts
index 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.ts
index 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/se
import { 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 TAgentVaultProxyServiceFactoryDep
agentVaultResolveDAL: 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 agentVaultProxyServiceFact
agentVaultResolveDAL,
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.md
index 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, grants
agent-vault-member/ product membership (list, add, role, remove)
- agent-vault-session/ mint, revoke, list, retention sweep
+ agent-vault-session/ mint, revoke, list, get
agent-vault-project/ the per-org project's lazy bootstrap and resolver
agent-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.ts
index 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 = async
agentVaultResolveDAL,
agentVaultServiceCustomHeaderDAL,
agentVaultServiceSubstitutionDAL,
+ agentVaultVariableDAL,
agentVaultSessionDAL,
+ agentVaultSessionLogConfigDAL,
membershipDAL,
orgDAL,
permissionService,
diff --cc docs/docs.json
index 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.tsx
index 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.ts
index 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 AgentVaultSessionScope
All = "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.tsx
index 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 @@@ import
TAgentVaultProxy,
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.tsx
index 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 @@@ import
TAgentVaultProductMemberOf,
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.ts
index 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 TAgentVaultProxySettingsDT
pollInterval?: 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.ts
index 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;