TypeScript
fix(settings): removing a secret provider clears the fields that used it (#31651)
Julius Marminge187781e9a0f0
diff --git a/apps/server/src/auth/RpcAuthorization.test.ts b/apps/server/src/auth/RpcAuthorization.test.tsindex 8044740a7e2..e59c428dca0 100644--- a/apps/server/src/auth/RpcAuthorization.test.ts+++ b/apps/server/src/auth/RpcAuthorization.test.ts@@ -192,6 +192,12 @@ describe("settings mutation authorization", () => {providerInstanceMutation,}).pipe(Effect.flip),).toMatchObject({ requiredPermission: AuthSettingsWriteScope });+ // Removing a secret provider clears settings fields that read from it.+ expect(+ yield* client[WS_METHODS.serverUpdateSettings]({+ patch: { secretProviders: { [SecretProviderId.make("personal")]: null } },+ }).pipe(Effect.flip),+ ).toMatchObject({ requiredPermission: AuthSettingsWriteScope });expect(handled).toBe(2);}).pipe(Effect.scoped),);diff --git a/apps/server/src/policy/managedProviders.ts b/apps/server/src/policy/managedProviders.tsindex ac390097e15..18877c6b542 100644--- a/apps/server/src/policy/managedProviders.ts+++ b/apps/server/src/policy/managedProviders.ts@@ -206,7 +206,8 @@ const sameVariable = (left === right ||(left !== undefined &&right !== undefined &&- left.value === right.value &&+ // A secret reference is an object, and a decoded copy is never the stored one.+ sameValue(left.value, right.value) &&left.sensitive === right.sensitive);const pinnedFields = (pin: ManagedProviderInstance): ReadonlyArray<PinnedConfigField> =>diff --git a/apps/server/src/serverSettings.test.ts b/apps/server/src/serverSettings.test.tsindex 622c7f55f0c..caba93a788b 100644--- a/apps/server/src/serverSettings.test.ts+++ b/apps/server/src/serverSettings.test.ts@@ -1716,6 +1716,86 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("server settings"}).pipe(Effect.provide(layerServerSettingsWithSecrets())),);+ it.effect("removing a secret provider unsets every field that read from it", () =>+ Effect.gen(function* () {+ const service = yield* ServerSettingsModule.ServerSettingsService;+ const personal = (reference: string) => ({+ provider: SecretProviderId.make("personal"),+ reference: `op://Private/${reference}`,+ });+ const work = { provider: SecretProviderId.make("work"), reference: "op://Work/token" };+ const instanceId = ProviderInstanceId.make("antigravity_refs");+ const hub = UsageLimitSourceId.make("hub");+ yield* decodeServerSettingsPatch({+ secretProviders: {+ personal: { kind: "one_password", label: "Personal", config: { account: "my" } },+ work: { kind: "one_password", label: "Work", config: { account: "work" } },+ },+ }).pipe(Effect.flatMap(service.updateSettings));+ yield* service.updateSettings({+ providerInstances: {+ [instanceId]: {+ driver: ProviderDriverKind.make("antigravity"),+ environment: [+ { name: "API_TOKEN", value: personal("Antigravity/env"), sensitive: true },+ { name: "WORK_TOKEN", value: work, sensitive: true },+ { name: "PLAIN", value: "kept", sensitive: false },+ ],+ },+ },+ sourceControlHosts: {+ bitbucket: { accessToken: personal("Bitbucket/token") },+ github: { tokens: { "github.com": personal("GitHub/token"), "ghe.acme.test": work } },+ },+ usageLimitSources: {+ [hub]: {+ kind: "cliproxy",+ url: "https://hub.test",+ managementKey: personal("Hub/key"),+ enabled: true,+ },+ },+ easDeviceHosts: [+ {+ kind: "eas",+ id: "eas",+ label: "EAS Simulator",+ accessToken: personal("Expo/token"),+ maxSessionMinutes: 30,+ idleMinutes: 10,+ maxConcurrentSessions: 2,+ },+ ],+ });++ // An older client's save echoes a reference it cannot decode as the redacted marker.+ const removed = yield* service.updateSettings({+ secretProviders: { [SecretProviderId.make("personal")]: null },+ usageLimitSources: {+ [hub]: {+ kind: "cliproxy",+ url: "https://hub.test",+ managementKey: SECRET_REDACTED,+ enabled: true,+ },+ },+ });+ assert.notInclude(JSON.stringify(removed), "op://Private");+ assert.deepEqual(removed.providerInstances[instanceId]?.environment, [+ { name: "WORK_TOKEN", value: work, sensitive: true },+ { name: "PLAIN", value: "kept", sensitive: false },+ ]);+ assert.equal(removed.sourceControlHosts.bitbucket?.accessToken, "");+ assert.deepEqual(removed.sourceControlHosts.github?.tokens, {+ "github.com": "",+ "ghe.acme.test": work,+ });+ assert.equal(removed.usageLimitSources[hub]?.managementKey, "");+ assert.equal(removed.easDeviceHosts[0]?.accessToken, "");+ assert.deepEqual(Object.keys(removed.secretProviders), ["work"]);+ }).pipe(Effect.provide(layerServerSettingsWithSecrets())),+ );+it.effect("knows every strictly decoded field that can hold a secret reference", () =>Effect.sync(() => {// Shipped clients decode these as strings. Each must be covered by the older-client case above.@@ -2731,6 +2811,36 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))();const restored = yield* withPolicy(undefined, (service) => service.getSettings);assert.equal(restored.providerInstances[claudeId]?.environment?.[0]?.value, token.value);++ // Removing a secret provider still clears a hidden variable that read from it.+ const reference = {+ provider: SecretProviderId.make("personal"),+ reference: "op://Private/Anthropic/key",+ };+ yield* withPolicy(undefined, (service) =>+ decodeServerSettingsPatch({+ secretProviders: {+ personal: { kind: "one_password", label: "Personal", config: { account: "my" } },+ },+ }).pipe(+ Effect.flatMap(service.updateSettings),+ Effect.andThen(+ service.updateProviderInstance({+ operation: "upsert",+ instanceId: claudeId,+ instance: {+ driver: claude,+ environment: [{ name: token.name, value: reference, sensitive: true }],+ },+ }),+ ),+ ),+ );+ yield* withPolicy(policy, (service) =>+ service.updateSettings({ secretProviders: { [reference.provider]: null } }),+ );+ const cleared = yield* withPolicy(undefined, (service) => service.getSettings);+ assert.notInclude(JSON.stringify(cleared), "op://Private");}).pipe(Effect.provide(shared));});diff --git a/apps/server/src/serverSettings.ts b/apps/server/src/serverSettings.tsindex 831a5fad499..565b388dc78 100644--- a/apps/server/src/serverSettings.ts+++ b/apps/server/src/serverSettings.ts@@ -65,6 +65,7 @@ import {import {mapSettingsSecrets,mapSettingsSecretValues,+ withoutRemovedSecretProviderReferences,SECRET_REDACTED,type SettingsSecret,} from "./settingsSecrets.ts";@@ -1171,7 +1172,9 @@ const make = Effect.gen(function* () {cause: parseFailure.value,});}- const updated = yield* update(current);+ // An older client echoes a reference as the redacted marker; restore it before vetting so+ // a removed provider's reference is cleared below rather than restored by persistence.+ const updated = withEchoedSecretReferences(current, yield* update(current));// Vet before secrets: a variable the policy hides from clients is not one they removed.const vetted = managed.vetWrite(current, yield* normalizeServerSettings(updated), patch);if (vetted._tag === "Locked") {@@ -1200,7 +1203,11 @@ const make = Effect.gen(function* () {managedBy: managedPolicy?.organization,});}- const persisted = yield* persistSettingsSecrets(current, vettedProviders.settings);+ // After vetting, which can keep stored variables a policy hides from clients.+ const persisted = yield* persistSettingsSecrets(+ current,+ withoutRemovedSecretProviderReferences(current, vettedProviders.settings),+ );const next = yield* normalizeServerSettings(persisted.settings);const materializedNext = yield* Effect.uninterruptibleMask(() =>Effect.gen(function* () {diff --git a/apps/server/src/settingsSecrets.ts b/apps/server/src/settingsSecrets.tsindex 17640237ff5..ce93b51a8eb 100644--- a/apps/server/src/settingsSecrets.ts+++ b/apps/server/src/settingsSecrets.ts@@ -239,3 +239,33 @@ function mapSecretFieldGroups(simlockDeviceHosts,};}++/**+ * `next` with every secret reference to a secret provider that `current` has and `next` dropped+ * unset: a credential field becomes empty, and a provider variable holding one is removed.+ */+export function withoutRemovedSecretProviderReferences(+ current: ServerSettings,+ next: ServerSettings,+): ServerSettings {+ const removed = new Set(+ Object.keys(current.secretProviders).filter((id) => !Object.hasOwn(next.secretProviders, id)),+ );+ if (removed.size === 0) return next;+ const isRemoved = (value: unknown) => isSecretReference(value) && removed.has(value.provider);+ const fields = mapSettingsSecretValues(next, (value) => (isRemoved(value) ? "" : value));+ return {+ ...fields,+ providerInstances: Object.fromEntries(+ Object.entries(fields.providerInstances).map(([instanceId, instance]) => [+ instanceId,+ instance.environment?.some((variable) => isRemoved(variable.value))+ ? {+ ...instance,+ environment: instance.environment.filter((variable) => !isRemoved(variable.value)),+ }+ : instance,+ ]),+ ),+ };+}diff --git a/apps/web/src/components/settings/SecretsSettings.logic.test.ts b/apps/web/src/components/settings/SecretsSettings.logic.test.tsnew file mode 100644index 00000000000..1a0ff29e11c--- /dev/null+++ b/apps/web/src/components/settings/SecretsSettings.logic.test.ts@@ -0,0 +1,51 @@+import { ServerSettings } from "@t3tools/contracts";+import * as Schema from "effect/Schema";+import { expect, it } from "vite-plus/test";++import { secretProviderUses } from "./SecretsSettings.logic";++const personal = (reference: string) => ({ provider: "personal", reference });+const work = { provider: "work", reference: "op://Work/token" };++const settings = Schema.decodeSync(ServerSettings)({+ providerInstances: {+ antigravity_work: {+ driver: "antigravity",+ displayName: "Antigravity Work",+ environment: [+ { name: "API_TOKEN", value: "", secret: personal("op://a/env") },+ { name: "OTHER_TOKEN", value: "", secret: work },+ ],+ },+ codex_plain: {+ driver: "codex",+ environment: [{ name: "CODEX_TOKEN", value: "", secret: personal("op://c/env") }],+ },+ },+ sourceControlHosts: {+ github: { tokens: { "github.com": personal("op://gh"), "ghe.acme.test": work } },+ },+ usageLimitSources: {+ hub: { kind: "cliproxy", url: "https://hub.test", managementKey: personal("op://hub") },+ },+ easDeviceHosts: [+ { kind: "eas", id: "eas", label: "EAS Simulator", accessToken: personal("op://expo") },+ ],+});++it.each([+ [+ "personal",+ [+ "Antigravity Work · API_TOKEN",+ "Codex · CODEX_TOKEN",+ "GitHub · github.com",+ "https://hub.test · Management Key",+ "EAS Simulator · Access Token",+ ],+ ],+ ["work", ["Antigravity Work · OTHER_TOKEN", "GitHub · ghe.acme.test"]],+ ["unused", []],+])("lists what reads from secret provider %s", (providerId, uses) => {+ expect(secretProviderUses(settings, providerId).map((use) => use.label)).toEqual(uses);+});diff --git a/apps/web/src/components/settings/SecretsSettings.logic.ts b/apps/web/src/components/settings/SecretsSettings.logic.tsnew file mode 100644index 00000000000..3ae528aed16--- /dev/null+++ b/apps/web/src/components/settings/SecretsSettings.logic.ts@@ -0,0 +1,90 @@+import {+ EasDeviceHostConfig,+ isSecretReference,+ secretReferencesInSettings,+ type ServerSettings,+ UsageLimitSourceConfig,+} from "@t3tools/contracts";+import { getProviderClient } from "@t3tools/client-runtime/provider-clients";+import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";++import { deriveProviderSettingsFields, type SettingsFormDefinition } from "./ProviderSettingsForm";++type SecretUseSettings = Pick<+ ServerSettings,+ "providerInstances" | "sourceControlHosts" | "usageLimitSources" | "easDeviceHosts"+>;++interface SecretProviderUse {+ readonly id: string;+ readonly label: string;+}++/** What reads from secret provider `providerId`, one readable name per field, in settings order. */+export function secretProviderUses(+ settings: SecretUseSettings,+ providerId: string,+): ReadonlyArray<SecretProviderUse> {+ const uses = (+ definition: SettingsFormDefinition,+ ownerId: string,+ owner: string,+ value: unknown,+ ): ReadonlyArray<SecretProviderUse> => {+ const labels = new Map(+ deriveProviderSettingsFields(definition).map((field) => [field.key, field.label] as const),+ );+ return secretReferencesInSettings(definition.settingsSchema, value).flatMap(+ ({ field, key, reference }) =>+ reference.provider === providerId+ ? [+ {+ id: `${ownerId}:${field}:${key ?? ""}`,+ label: `${owner} · ${key ?? labels.get(field) ?? field}`,+ },+ ]+ : [],+ );+ };++ return [+ ...Object.entries(settings.providerInstances).flatMap(([instanceId, instance]) => {+ const client = getProviderClient(instance.driver);+ const owner = instance.displayName ?? client?.label ?? instanceId;+ return [+ ...(client ? uses(client, `provider:${instanceId}`, owner, instance.config) : []),+ ...(instance.environment ?? []).flatMap((variable) =>+ isSecretReference(variable.value) && variable.value.provider === providerId+ ? [+ {+ id: `provider:${instanceId}:env:${variable.name}`,+ label: `${owner} · ${variable.name}`,+ },+ ]+ : [],+ ),+ ];+ }),+ ...sourceControlClients.definitions.flatMap((definition) =>+ definition.settings+ ? uses(+ { settingsSchema: definition.settings },+ `source-control:${definition.kind}`,+ definition.label,+ settings.sourceControlHosts[definition.kind],+ )+ : [],+ ),+ ...Object.entries(settings.usageLimitSources).flatMap(([id, source]) =>+ uses(+ { settingsSchema: UsageLimitSourceConfig },+ `usage-limit:${id}`,+ source.label ?? source.url,+ source,+ ),+ ),+ ...settings.easDeviceHosts.flatMap((host) =>+ uses({ settingsSchema: EasDeviceHostConfig }, `eas:${host.id}`, host.label, host),+ ),+ ];+}diff --git a/apps/web/src/components/settings/SecretsSettings.tsx b/apps/web/src/components/settings/SecretsSettings.tsxindex 2ff329ca6b7..9555e257503 100644--- a/apps/web/src/components/settings/SecretsSettings.tsx+++ b/apps/web/src/components/settings/SecretsSettings.tsx@@ -1,4 +1,4 @@-import type { SecretProviderConfig, SecretProviderId } from "@t3tools/contracts";+import type { EnvironmentId, SecretProviderConfig, SecretProviderId } from "@t3tools/contracts";import { PlusIcon } from "lucide-react";import { useState } from "react";@@ -18,6 +18,7 @@ import {import { Button } from "../ui/button";import { SecretProviderDialog } from "./SecretProviderDialog";import { classifySecretProvider } from "./SecretProviderDialog.logic";+import { secretProviderUses } from "./SecretsSettings.logic";import {classifyProviderEnvironmentAccess,resolveRemoteOperateAccess,@@ -164,6 +165,8 @@ function EnvironmentSecretProviders({</Button>) : null}<RemoveSecretProviderButton+ environmentId={environmentId}+ id={id}label={config.label}onConfirm={() => updateSettings({ secretProviders: { [id]: null } })}/>@@ -189,9 +192,13 @@ function EnvironmentSecretProviders({}function RemoveSecretProviderButton({+ environmentId,+ id,label,onConfirm,}: {+ readonly environmentId: EnvironmentId;+ readonly id: SecretProviderId;readonly label: string;readonly onConfirm: () => void;}) {@@ -205,10 +212,7 @@ function RemoveSecretProviderButton({<AlertDialogPopup><AlertDialogHeader><AlertDialogTitle>Remove {label}?</AlertDialogTitle>- <AlertDialogDescription>- Provider variables that read from {label} stop resolving until a provider with the- same name is added again. The secrets themselves are untouched.- </AlertDialogDescription>+ <SecretProviderUses environmentId={environmentId} id={id} label={label} /></AlertDialogHeader><AlertDialogFooter><AlertDialogClose render={<Button variant="outline" />}>Cancel</AlertDialogClose>@@ -227,3 +231,34 @@ function RemoveSecretProviderButton({</>);}++function SecretProviderUses({+ environmentId,+ id,+ label,+}: {+ readonly environmentId: EnvironmentId;+ readonly id: SecretProviderId;+ readonly label: string;+}) {+ const uses = secretProviderUses(useEnvironmentSettings(environmentId), id);+ if (uses.length === 0) {+ return (+ <AlertDialogDescription>+ Nothing reads from {label}. The secrets themselves are untouched.+ </AlertDialogDescription>+ );+ }+ return (+ <>+ <AlertDialogDescription>+ These read from {label} and will be unset. The secrets themselves are untouched.+ </AlertDialogDescription>+ <ul className="max-h-48 list-disc space-y-0.5 overflow-y-auto ps-5 text-sm wrap-anywhere">+ {uses.map((use) => (+ <li key={use.id}>{use.label}</li>+ ))}+ </ul>+ </>+ );+}diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.tsindex a726135bcca..78599ff888e 100644--- a/packages/contracts/src/settings.ts+++ b/packages/contracts/src/settings.ts@@ -1744,6 +1744,10 @@ export function requiredScopesForServerSettingsPatch(changesSettings = true;}}+ // Removing a secret provider also clears the settings fields that read from it.+ if (Object.values(patch.secretProviders ?? {}).some((entry) => entry === null)) {+ changesSettings = true;+ }return [...(changesSettings || !changesProviders ? [AuthSettingsWriteScope] : []),...(changesProviders ? [AuthProvidersManageScope] : []),