Skip to content
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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.tsx
index 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.ts
index 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] : []),