@devries-cameron20 / t3code Mirror · read-only / commits / ee9e36c8b2
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 18:30 UTC

feat(secrets): check a secret reference before saving it (#31723)

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com> Co-authored-by: Julius Marminge <julius0216@outlook.com> Co-authored-by: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>

Yordis Prieto committed Nov 12, 2026 at 16:05 UTC ee9e36c8b20e739f107bdbacea82d12f912d97b1
29 files changed +807 -95
apps/server/src/environment/ServerEnvironment.ts
+1
@@ -237,6 +237,7 @@ export const make = Effect.gen(function* () {
237 storageCleanupRun: true,
238 databaseStorage: true,
239 otlpEndpointCheck: true,
240 + secretSourceCheck: true,
241 projectWorktreeCleanup: true,
242 settledWorktreeCleanup: true,
243 worktreesDirectory: true,
apps/server/src/observability/RpcInstrumentation.ts
+1
@@ -81,6 +81,7 @@ const RPC_AGGREGATES = {
81 [WS_METHODS.serverDisableAcpRegistryProvider]: "server",
82 [WS_METHODS.serverLogoutAcpRegistry]: "server",
83 [WS_METHODS.serverDiscoverSourceControl]: "server",
84 + [WS_METHODS.serverCheckSecretSource]: "server",
85 [WS_METHODS.serverGetTraceDiagnostics]: "server",
86 [WS_METHODS.serverGetProcessDiagnostics]: "server",
87 [WS_METHODS.serverGetHostResources]: "server",
apps/server/src/provider/ProviderInstanceRegistry.ts
+144 -38
@@ -92,9 +92,20 @@ const withoutSecretReferences = (
92 typeof variable.value === "string" ? [{ ...variable, value: variable.value }] : [],
93 );
94
95 +interface CheckedSecret {
96 + readonly reference: SecretReference;
97 + readonly value: string;
98 +}
99 +
100 +const sameReference = (a: SecretReference, b: SecretReference) =>
101 + a.provider === b.provider && a.reference === b.reference;
102 +
103 +// `checked` supplies its reference's value instead of the resolver, which a concurrent refresh
104 +// may have re-read since the check.
105 const readInstanceSecrets = Effect.fn("ProviderInstanceRegistry.readInstanceSecrets")(function* <R>(
106 driver: AnyProviderDriver<R> | undefined,
107 entry: ProviderInstanceConfig,
108 + checked?: CheckedSecret,
109 ) {
110 const variables = entry.environment ?? [];
111 const configFields = configSecretReferences(driver, entry);
@@ -102,8 +113,15 @@ const readInstanceSecrets = Effect.fn("ProviderInstanceRegistry.readInstanceSecr
113 ...secretReferencesIn(variables),
114 ...configFields.map(({ reference }) => reference),
115 ];
105 - const values =
106 - references.length === 0 ? [] : yield* (yield* SecretResolver.SecretResolver).read(references);
116 + const isChecked = (reference: SecretReference) =>
117 + checked !== undefined && sameReference(reference, checked.reference);
118 + const toRead = references.filter((reference) => !isChecked(reference));
119 + const read =
120 + toRead.length === 0 ? [] : yield* (yield* SecretResolver.SecretResolver).read(toRead);
121 + let readIndex = 0;
122 + const values = references.map((reference) =>
123 + isChecked(reference) ? checked?.value : read[readIndex++],
124 + );
125 const unreadable: Array<string> = [];
126 let index = 0;
127 // An empty secret reads as unreadable, so a driver cannot fall back to an inherited credential.
@@ -130,6 +148,36 @@ const readInstanceSecrets = Effect.fn("ProviderInstanceRegistry.readInstanceSecr
148 return { secrets, unreadable };
149 });
150
151 +// Replaces only the checked reference's value in the secrets a live instance already holds, so
152 +// another reference whose read failed earlier is not read again and does not park the instance.
153 +const carryCheckedSecret = <R>(
154 + driver: AnyProviderDriver<R> | undefined,
155 + entry: ProviderInstanceConfig,
156 + current: InstanceSecrets,
157 + { reference: checked, value }: CheckedSecret,
158 +): InstanceSecrets => {
159 + const matches = (reference: SecretReference) => sameReference(reference, checked);
160 + // A live instance resolved every variable in order, so slots line up with the entry's variables
161 + // by position; names may repeat.
162 + const variables = entry.environment ?? [];
163 + const replacedSlots = configSecretReferences(driver, entry).filter(({ reference }) =>
164 + matches(reference),
165 + );
166 + return {
167 + environment: current.environment.map((variable, index) => {
168 + const source = variables[index]?.value;
169 + return source !== undefined && typeof source !== "string" && matches(source)
170 + ? { ...variable, value }
171 + : variable;
172 + }),
173 + config: current.config.map((slot) =>
174 + replacedSlots.some(({ field, key }) => field === slot.field && key === slot.key)
175 + ? { ...slot, value }
176 + : slot,
177 + ),
178 + };
179 +};
180 +
181 /** Conflicting saved flags must preserve any explicit disable. */
182 const resolveEntryEnabled = (entry: ProviderInstanceConfig, typedConfig: unknown): boolean => {
183 const rawConfigEnabled = providerInstanceConfigEnabledFlag(entry.config);
@@ -161,6 +209,7 @@ const buildEntry = Effect.fn("ProviderInstanceRegistry.buildEntry")(function* <R
209 readonly rawInstanceId: string;
210 readonly entry: ProviderInstanceConfig;
211 readonly deferSecrets: boolean;
212 + readonly carriedSecrets?: InstanceSecrets | undefined;
213 }): Effect.fn.Return<
214 | { readonly kind: "live"; readonly live: LiveEntry }
215 | {
@@ -171,7 +220,15 @@ const buildEntry = Effect.fn("ProviderInstanceRegistry.buildEntry")(function* <R
220 never,
221 R | SecretResolver.SecretResolver
222 > {
174 - const { driversById, parentScope, instanceId, rawInstanceId, entry, deferSecrets } = input;
223 + const {
224 + driversById,
225 + parentScope,
226 + instanceId,
227 + rawInstanceId,
228 + entry,
229 + deferSecrets,
230 + carriedSecrets,
231 + } = input;
232 const blocked = input.blockedReason(entry.driver);
233 if (blocked !== undefined) {
234 return {
@@ -235,12 +292,14 @@ const buildEntry = Effect.fn("ProviderInstanceRegistry.buildEntry")(function* <R
292 }),
293 };
294 }
238 - const { secrets, unreadable } = enabled
239 - ? yield* readInstanceSecrets(driver, entry)
240 - : {
241 - secrets: { environment: withoutSecretReferences(entry.environment ?? []), config: [] },
242 - unreadable: [],
243 - };
295 + const { secrets, unreadable } = carriedSecrets
296 + ? { secrets: carriedSecrets, unreadable: [] }
297 + : enabled
298 + ? yield* readInstanceSecrets(driver, entry)
299 + : {
300 + secrets: { environment: withoutSecretReferences(entry.environment ?? []), config: [] },
301 + unreadable: [],
302 + };
303 // Starting with a blank credential would fail later with a less useful error, or fall back to
304 // whatever the server inherited.
305 if (unreadable.length > 0) {
@@ -311,9 +370,10 @@ const makeReconcile = <R>(input: {
370 configMap: ProviderInstanceConfigMap,
371 rebuild?: ReadonlySet<ProviderInstanceId>,
372 deferSecrets?: boolean,
373 + carried?: ReadonlyMap<ProviderInstanceId, InstanceSecrets>,
374 ) => Effect.Effect<void, never, R | SecretResolver.SecretResolver>) => {
375 const { state, driversById, blockedReason, parentScope } = input;
316 - return (configMap, rebuild = new Set(), deferSecrets = false) =>
376 + return (configMap, rebuild = new Set(), deferSecrets = false, carried = new Map()) =>
377 Effect.gen(function* () {
378 const previousEntries = yield* Ref.get(state.entries);
379 const previousUnavailable = yield* Ref.get(state.unavailable);
@@ -365,6 +425,7 @@ const makeReconcile = <R>(input: {
425 const instanceId = ProviderInstanceId.make(rawInstanceId);
426 const kept = previousEntries.has(instanceId) && !replacedIds.has(instanceId);
427 return kept ||
428 + carried.has(instanceId) ||
429 parkedSnapshot(instanceId, entry) !== undefined ||
430 !(yield* isEntryEnabled(driversById, entry))
431 ? []
@@ -406,6 +467,7 @@ const makeReconcile = <R>(input: {
467 rawInstanceId,
468 entry,
469 deferSecrets,
470 + carriedSecrets: carried.get(instanceId),
471 });
472 if (result.kind === "live") {
473 builtEntries.set(instanceId, result.live);
@@ -503,44 +565,87 @@ export const makeProviderInstanceRegistry = Effect.fn(
565 );
566
567 // Rebuilds an instance only when it was unavailable or its secrets changed, so a refresh does
506 - // not restart providers whose credentials are the same.
507 - const reloadSecrets: ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutatorShape["reloadSecrets"] =
508 - Effect.fn("ProviderInstanceRegistry.reloadSecrets")(
509 - function* (instanceId) {
510 - const configMap = yield* Ref.get(configMapRef);
511 - const targets = yield* Effect.filter(Object.entries(configMap), ([rawInstanceId, entry]) =>
512 - (instanceId === undefined || rawInstanceId === instanceId) &&
513 - secretReferencesOf(driversById, entry).length > 0
514 - ? isEntryEnabled(driversById, entry)
515 - : Effect.succeed(false),
516 - );
517 - if (targets.length === 0) return;
568 + // not restart providers whose credentials are the same. Without `checked` the cached values are
569 + // dropped first; with it, only that reference takes the checked value and the rest carry over.
570 + const reloadWhere = Effect.fn("ProviderInstanceRegistry.reloadWhere")(
571 + function* (
572 + select: (rawInstanceId: string, entry: ProviderInstanceConfig) => boolean,
573 + checked?: CheckedSecret,
574 + ) {
575 + const configMap = yield* Ref.get(configMapRef);
576 + const targets = yield* Effect.filter(Object.entries(configMap), ([rawInstanceId, entry]) =>
577 + select(rawInstanceId, entry) && secretReferencesOf(driversById, entry).length > 0
578 + ? isEntryEnabled(driversById, entry)
579 + : Effect.succeed(false),
580 + );
581 + if (targets.length === 0) return [];
582 + if (checked === undefined) {
583 const resolver = yield* SecretResolver.SecretResolver;
584 const references = targets.flatMap(([, entry]) => secretReferencesOf(driversById, entry));
585 yield* resolver.invalidate(references);
586 yield* resolver.read(references);
522 - const live = yield* Ref.get(entries);
523 - const rebuild = new Set<ProviderInstanceId>();
524 - for (const [rawInstanceId, entry] of targets) {
525 - const current = live.get(ProviderInstanceId.make(rawInstanceId));
526 - if (current === undefined) {
527 - rebuild.add(ProviderInstanceId.make(rawInstanceId));
528 - continue;
587 + }
588 + const live = yield* Ref.get(entries);
589 + const rebuild = new Set<ProviderInstanceId>();
590 + const carried = new Map<ProviderInstanceId, InstanceSecrets>();
591 + for (const [rawInstanceId, entry] of targets) {
592 + const instanceId = ProviderInstanceId.make(rawInstanceId);
593 + const current = live.get(instanceId);
594 + if (current === undefined) {
595 + rebuild.add(instanceId);
596 + if (checked !== undefined) {
597 + const { secrets, unreadable } = yield* readInstanceSecrets(
598 + driversById.get(entry.driver),
599 + entry,
600 + checked,
601 + );
602 + if (unreadable.length === 0) carried.set(instanceId, secrets);
603 }
530 - const { secrets, unreadable } = yield* readInstanceSecrets(
604 + continue;
605 + }
606 + if (checked !== undefined) {
607 + const secrets = carryCheckedSecret(
608 driversById.get(entry.driver),
532 - entry,
609 + current.entry,
610 + current.secrets,
611 + checked,
612 );
534 - // A failed re-read keeps the working instance and the value it already holds.
535 - if (unreadable.length === 0 && !Equal.equals(secrets, current.secrets)) {
613 + if (!Equal.equals(secrets, current.secrets)) {
614 rebuild.add(current.instance.instanceId);
615 + carried.set(current.instance.instanceId, secrets);
616 }
617 + continue;
618 }
539 - yield* reconcileWithR(configMap, rebuild);
540 - },
541 - (effect) => semaphore.withPermits(1)(effect),
542 - Effect.provideContext(driverContext),
543 - );
619 + const { secrets, unreadable } = yield* readInstanceSecrets(
620 + driversById.get(entry.driver),
621 + entry,
622 + );
623 + // A failed re-read keeps the working instance and the value it already holds.
624 + if (unreadable.length === 0 && !Equal.equals(secrets, current.secrets)) {
625 + rebuild.add(current.instance.instanceId);
626 + }
627 + }
628 + yield* reconcileWithR(configMap, rebuild, false, carried);
629 + return targets.map(([rawInstanceId]) => ProviderInstanceId.make(rawInstanceId));
630 + },
631 + (effect) => semaphore.withPermits(1)(effect),
632 + Effect.provideContext(driverContext),
633 + );
634 + const reloadSecrets: ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutatorShape["reloadSecrets"] =
635 + (instanceId) =>
636 + reloadWhere(
637 + (rawInstanceId) => instanceId === undefined || rawInstanceId === instanceId,
638 + undefined,
639 + ).pipe(Effect.asVoid);
640 + const applySecret: ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutatorShape["applySecret"] =
641 + (reference, value) =>
642 + reloadWhere(
643 + (_, entry) =>
644 + secretReferencesOf(driversById, entry).some((candidate) =>
645 + sameReference(candidate, reference),
646 + ),
647 + { reference, value },
648 + );
649
650 // Reading secrets can wait on a vault unlock, so the server does not wait for it to start.
651 yield* semaphore.withPermits(1)(
@@ -592,6 +697,7 @@ export const makeProviderInstanceRegistry = Effect.fn(
697 const mutator: ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutatorShape = {
698 reconcile,
699 reloadSecrets,
700 + applySecret,
701 };
702
703 return { registry, mutator };
apps/server/src/provider/ProviderInstanceRegistryHydration.test.ts
+1
@@ -165,6 +165,7 @@ describe("layerSettingsWatcher", () => {
165 const mutator = Layer.succeed(ProviderInstanceRegistryMutator, {
166 reconcile: () => Queue.offer(reconciled, undefined),
167 reloadSecrets: () => Effect.sync(() => void reloads++),
168 + applySecret: () => Effect.succeed([]),
169 });
170 yield* Layer.build(
171 layerSettingsWatcher(Stream.fromQueue(changes), initial).pipe(Layer.provide(mutator)),
apps/server/src/provider/ProviderInstanceRegistryMutator.ts
+13 -1
@@ -1,5 +1,9 @@
1 /** Reconcile closes removed/replaced scopes before creating replacements: at most one live instance per id. */
2 -import type { ProviderInstanceConfigMap, ProviderInstanceId } from "@t3tools/contracts";
2 +import type {
3 + ProviderInstanceConfigMap,
4 + ProviderInstanceId,
5 + SecretReference,
6 +} from "@t3tools/contracts";
7 import * as Context from "effect/Context";
8 import type * as Effect from "effect/Effect";
9
@@ -7,6 +11,14 @@ export interface ProviderInstanceRegistryMutatorShape {
11 readonly reconcile: (configMap: ProviderInstanceConfigMap) => Effect.Effect<void>;
12 /** Re-reads the secrets of every instance, or one, and rebuilds those whose secrets changed. */
13 readonly reloadSecrets: (instanceId?: ProviderInstanceId) => Effect.Effect<void>;
14 + /**
15 + * Rebuilds the instances that read `reference` with `value`, keeping the other secrets a live
16 + * instance holds, and returns them. A parked instance reads its other secrets from the resolver.
17 + */
18 + readonly applySecret: (
19 + reference: SecretReference,
20 + value: string,
21 + ) => Effect.Effect<ReadonlyArray<ProviderInstanceId>>;
22 }
23
24 export class ProviderInstanceRegistryMutator extends Context.Service<
apps/server/src/provider/ProviderRegistry.ts
+18
@@ -4,6 +4,7 @@ import {
4 isProviderWorkspaceSnapshotPending,
5 ProviderDriverKind,
6 type ProviderInstanceId,
7 + type SecretReference,
8 type ServerProvider,
9 type ServerProviderUpdateState,
10 } from "@t3tools/contracts";
@@ -70,6 +71,12 @@ export class ProviderRegistry extends Context.Service<
71 instanceId?: ProviderInstanceId,
72 ) => Effect.Effect<ReadonlyArray<ServerProvider>>;
73
74 + /** Rebuilds and refreshes only the instances that read a secret, with the value the caller just read. */
75 + readonly applySecretAndRefresh: (
76 + reference: SecretReference,
77 + value: string,
78 + ) => Effect.Effect<ReadonlyArray<ServerProvider>>;
79 +
80 /** Only refreshed instances can verify an update; the published list still includes every row. */
81 readonly refreshAfterUpdate: (
82 provider: ProviderDriverKind,
@@ -739,6 +746,15 @@ export const layer = Layer.effect(
746 return yield* instanceId === undefined ? refresh() : refreshInstance(instanceId);
747 });
748
749 + const applySecretAndRefresh = Effect.fn("applySecretAndRefresh")(function* (
750 + reference: SecretReference,
751 + value: string,
752 + ) {
753 + const instanceIds = yield* instanceRegistryMutator.applySecret(reference, value);
754 + yield* Effect.forEach(instanceIds, refreshInstance, { discard: true });
755 + return yield* Ref.get(providersRef);
756 + });
757 +
758 const refreshAfterUpdate = Effect.fn("refreshAfterUpdate")(function* (
759 provider: ProviderDriverKind,
760 selectedInstanceId: ProviderInstanceId,
@@ -1176,6 +1192,8 @@ export const layer = Layer.effect(
1192 refreshInstance(instanceId).pipe(Effect.catchCause(recoverRefreshFailure)),
1193 reloadSecretsAndRefresh: (instanceId?: ProviderInstanceId) =>
1194 reloadSecretsAndRefresh(instanceId).pipe(Effect.catchCause(recoverRefreshFailure)),
1195 + applySecretAndRefresh: (reference: SecretReference, value: string) =>
1196 + applySecretAndRefresh(reference, value).pipe(Effect.catchCause(recoverRefreshFailure)),
1197 refreshWorkspaceSnapshot: (input) =>
1198 refreshWorkspaceSnapshot(input).pipe(Effect.catchCause(recoverRefreshFailure)),
1199 refreshAfterUpdate,
apps/server/src/provider/providerMaintenanceRunner.test.ts
+1
@@ -207,6 +207,7 @@ function makeRegistry(
207 refresh: () => Ref.get(providersRef),
208 refreshInstance: () => Ref.get(providersRef),
209 reloadSecretsAndRefresh: () => Ref.get(providersRef),
210 + applySecretAndRefresh: () => Ref.get(providersRef),
211 refreshAfterUpdate: () => {
212 const version = options?.installedVersionAfterUpdate;
213 if (version === undefined) {
apps/server/src/provider/testUtils/providerRegistryMock.ts
+1
@@ -12,6 +12,7 @@ const makeProviderRegistryMock = (
12 refresh: () => Effect.succeed(providers),
13 refreshInstance: () => Effect.succeed(providers),
14 reloadSecretsAndRefresh: () => Effect.succeed(providers),
15 + applySecretAndRefresh: () => Effect.succeed(providers),
16 refreshAfterUpdate: () => Effect.succeed(providers),
17 refreshWorkspaceSnapshot: () => Effect.succeed(providers),
18 invalidateModelCaches: () => Effect.void,
apps/server/src/secrets/SecretCheck.test.ts new
+363
@@ -0,0 +1,363 @@
1 +import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 +import * as NodeServices from "@effect/platform-node/NodeServices";
3 +import { assert, it } from "@effect/vitest";
4 +import {
5 + ProviderDriverKind,
6 + ProviderInstanceId,
7 + SecretProviderId,
8 + SecretProviderKind,
9 + type SecretReference,
10 + SettingsSecretValue,
11 + type ServerProvider,
12 +} from "@t3tools/contracts";
13 +import type { AnyProviderDriver, ProviderInstance } from "@t3tools/provider-core/server/driver";
14 +import { makeManualOnlyProviderMaintenanceCapabilities } from "@t3tools/provider-core/server/maintenanceResolver";
15 +import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
16 +import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver";
17 +import { defineSecretProviderDriver } from "@t3tools/secret-provider-core/server/driver";
18 +import { defineSecretProvider } from "@t3tools/secret-provider-core/shared/definition";
19 +import * as Deferred from "effect/Deferred";
20 +import * as Effect from "effect/Effect";
21 +import * as Fiber from "effect/Fiber";
22 +import { HttpClient, HttpClientResponse } from "effect/http";
23 +import * as Layer from "effect/Layer";
24 +import * as PubSub from "effect/PubSub";
25 +import * as Schema from "effect/Schema";
26 +import * as Stream from "effect/Stream";
27 +
28 +import * as ServerConfig from "../config.ts";
29 +import * as ModelManifest from "../provider/ModelManifest.ts";
30 +import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
31 +import * as ProviderInstanceRegistryMutator from "../provider/ProviderInstanceRegistryMutator.ts";
32 +import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
33 +import * as SecretCheck from "./SecretCheck.ts";
34 +
35 +const FAKE_KIND = SecretProviderKind.make("fake");
36 +const secretProvider = SecretProviderId.make("personal");
37 +const wanted: SecretReference = { provider: secretProvider, reference: "fake://wanted" };
38 +const other: SecretReference = { provider: secretProvider, reference: "fake://other" };
39 +const locked: SecretReference = { provider: secretProvider, reference: "fake://locked" };
40 +const driverKind = ProviderDriverKind.make("fake-provider");
41 +const dependent = ProviderInstanceId.make("dependent");
42 +const unrelated = ProviderInstanceId.make("unrelated");
43 +
44 +const providerSnapshot = (instanceId: ProviderInstanceId): ServerProvider => ({
45 + instanceId,
46 + driver: driverKind,
47 + status: "ready",
48 + enabled: true,
49 + installed: true,
50 + auth: { status: "authenticated" },
51 + checkedAt: "2026-10-03T00:00:00.000Z",
52 + version: "1.0.0",
53 + models: [],
54 + slashCommands: [],
55 + skills: [],
56 +});
57 +
58 +/**
59 + * A server whose `dependent` instance reads `dependentReads` and `unrelated` reads `other`, all
60 + * through the real resolver, instance registry and provider registry. `vault` answers each read of
61 + * a reference with the next queued value, repeating the last one, after `beforeRead`.
62 + */
63 +const setup = Effect.fn("SecretCheckTest.setup")(function* (
64 + vault: Map<string, Array<string | undefined>>,
65 + dependentReads: ReadonlyArray<SecretReference> = [wanted],
66 + options: {
67 + readonly dependentConfig?: unknown;
68 + readonly beforeRead?: (reference: string) => Effect.Effect<void>;
69 + } = {},
70 +) {
71 + const reads: Array<string> = [];
72 + const created: Array<{ instanceId: ProviderInstanceId; secrets: ReadonlyArray<unknown> }> = [];
73 + const createdConfigs: Array<unknown> = [];
74 + const refreshed: Array<ProviderInstanceId> = [];
75 +
76 + const secretDriver = defineSecretProviderDriver({
77 + kind: FAKE_KIND,
78 + definition: defineSecretProvider({
79 + kind: FAKE_KIND,
80 + label: "Fake",
81 + configSchema: Schema.Struct({}),
82 + isReference: (value) => value.startsWith("fake://"),
83 + referencePlaceholder: "fake://item",
84 + invalidReferenceMessage: "Use fake://item.",
85 + }),
86 + read: (_config, references) =>
87 + Effect.forEach(references, (reference) =>
88 + (options.beforeRead?.(reference) ?? Effect.void).pipe(
89 + Effect.andThen(
90 + Effect.sync(() => {
91 + reads.push(reference);
92 + const answers = vault.get(reference) ?? [];
93 + return answers.length > 1 ? answers.shift() : answers[0];
94 + }),
95 + ),
96 + ),
97 + ),
98 + });
99 +
100 + const driver: AnyProviderDriver = {
101 + driverKind,
102 + metadata: { displayName: "Fake" },
103 + configSchema: Schema.Struct({
104 + keys: Schema.Record(Schema.String, SettingsSecretValue).pipe(
105 + Schema.withDecodingDefault(Effect.succeed({})),
106 + ),
107 + }),
108 + defaultConfig: () => ({}),
109 + create: (input) =>
110 + Effect.sync(() => {
111 + created.push({
112 + instanceId: input.instanceId,
113 + secrets: input.environment.map((variable) => variable.value),
114 + });
115 + createdConfigs.push(input.config);
116 + const snapshot = providerSnapshot(input.instanceId);
117 + return {
118 + instanceId: input.instanceId,
119 + driverKind,
120 + continuationIdentity: { driverKind, continuationKey: `fake:${input.instanceId}` },
121 + displayName: undefined,
122 + enabled: input.enabled,
123 + snapshot: {
124 + resolveMaintenance: () =>
125 + Effect.succeed(
126 + makeManualOnlyProviderMaintenanceCapabilities({
127 + provider: driverKind,
128 + packageName: null,
129 + }),
130 + ),
131 + getSnapshot: Effect.succeed(snapshot),
132 + refresh: Effect.sync(() => {
133 + refreshed.push(input.instanceId);
134 + return snapshot;
135 + }),
136 + streamChanges: Stream.empty,
137 + applyUsageLimits: () => Effect.void,
138 + },
139 + orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
140 + textGeneration: {} as ProviderInstance["textGeneration"],
141 + } satisfies ProviderInstance;
142 + }),
143 + };
144 + const instanceConfig = (secrets: ReadonlyArray<SecretReference>, config: unknown = {}) => ({
145 + driver: driverKind,
146 + config,
147 + environment: secrets.map((secret, index) => ({
148 + name: `API_KEY_${index}`,
149 + value: secret,
150 + sensitive: true,
151 + })),
152 + });
153 +
154 + const resolverContext = yield* Layer.build(
155 + SecretResolver.layer({
156 + drivers: [secretDriver],
157 + secretProviders: Effect.succeed({
158 + [secretProvider]: { kind: FAKE_KIND, label: "Personal", config: {} },
159 + }),
160 + }),
161 + );
162 + const { registry, mutator } = yield* ProviderInstanceRegistry.makeProviderInstanceRegistry({
163 + drivers: [driver],
164 + configMap: {
165 + [dependent]: instanceConfig(dependentReads, options.dependentConfig),
166 + [unrelated]: instanceConfig([other]),
167 + },
168 + }).pipe(Effect.provide(resolverContext));
169 + // Secrets are read after startup, so wait for the change that applies them.
170 + const changes = yield* registry.subscribeChanges;
171 + yield* PubSub.take(changes);
172 +
173 + const services = yield* Layer.build(
174 + SecretCheck.layer.pipe(
175 + Layer.provideMerge(ProviderRegistry.layer),
176 + Layer.provide(
177 + Layer.mergeAll(
178 + Layer.succeedContext(resolverContext),
179 + Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, registry),
180 + Layer.succeed(ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator, mutator),
181 + ),
182 + ),
183 + ),
184 + );
185 + const secretCheck = yield* SecretCheck.SecretCheck.pipe(Effect.provide(services));
186 + const resolver = yield* SecretResolver.SecretResolver.pipe(Effect.provide(resolverContext));
187 + return { secretCheck, registry, mutator, resolver, reads, created, createdConfigs, refreshed };
188 +});
189 +
190 +const layerTest = Layer.mergeAll(
191 + ServerConfig.layerTest(process.cwd(), { prefix: "t3-secret-check-" }),
192 + ModelManifest.layerTest,
193 + ProviderLatestVersions.layer,
194 + Layer.succeed(
195 + HttpClient.HttpClient,
196 + HttpClient.make((request) =>
197 + Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ version: "0.0.0" }))),
198 + ),
199 + ),
200 +).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
201 +
202 +it.layer(layerTest)("SecretCheck", (it) => {
203 + it.effect(
204 + "a readable secret rebuilds and refreshes only the instances that read it, from that one read",
205 + () =>
206 + Effect.gen(function* () {
207 + const vault = new Map<string, Array<string | undefined>>([
208 + [wanted.reference, [undefined]],
209 + [other.reference, ["other-key"]],
210 + ]);
211 + const server = yield* setup(vault);
212 + assert.deepStrictEqual(
213 + (yield* server.registry.listUnavailable).map((entry) => entry.instanceId),
214 + [dependent],
215 + );
216 + const createdBefore = server.created.length;
217 + const readsBefore = server.reads.length;
218 +
219 + // Unlocked for the check's own read only: any second read would fail again.
220 + vault.set(wanted.reference, ["wanted-key", undefined]);
221 + const result = yield* server.secretCheck.check(wanted);
222 +
223 + assert.deepStrictEqual(result, { _tag: "Resolved" });
224 + assert.notInclude(JSON.stringify(result), "wanted-key");
225 + assert.deepStrictEqual(server.reads.slice(readsBefore), [wanted.reference]);
226 + assert.deepStrictEqual(server.created.slice(createdBefore), [
227 + { instanceId: dependent, secrets: ["wanted-key"] },
228 + ]);
229 + assert.deepStrictEqual(server.refreshed, [dependent]);
230 + assert.deepStrictEqual(yield* server.registry.listUnavailable, []);
231 + }).pipe(Effect.scoped),
232 + );
233 +
234 + it.effect("an unreadable secret fails naming its provider and leaves instances alone", () =>
235 + Effect.gen(function* () {
236 + const vault = new Map<string, Array<string | undefined>>([
237 + [wanted.reference, [undefined]],
238 + [other.reference, ["other-key"]],
239 + ]);
240 + const server = yield* setup(vault);
241 + const createdBefore = server.created.length;
242 +
243 + const result = yield* server.secretCheck.check(wanted);
244 +
245 + assert.strictEqual(result._tag, "Failed");
246 + if (result._tag === "Failed") assert.include(result.detail, "Personal");
247 + assert.deepStrictEqual(server.created.slice(createdBefore), []);
248 + assert.deepStrictEqual(server.refreshed, []);
249 + assert.deepStrictEqual(
250 + (yield* server.registry.listUnavailable).map((entry) => entry.instanceId),
251 + [dependent],
252 + );
253 + }).pipe(Effect.scoped),
254 + );
255 +
256 + it.effect("a failed check keeps the value the server already holds", () =>
257 + Effect.gen(function* () {
258 + const vault = new Map<string, Array<string | undefined>>([
259 + [wanted.reference, ["wanted-key"]],
260 + [locked.reference, ["locked-key", undefined]],
261 + [other.reference, ["other-key"]],
262 + ]);
263 + const server = yield* setup(vault, [wanted, locked]);
264 + const readsBefore = server.reads.length;
265 +
266 + assert.strictEqual((yield* server.secretCheck.check(locked))._tag, "Failed");
267 +
268 + assert.deepStrictEqual(yield* server.resolver.read([locked]), ["locked-key"]);
269 + assert.deepStrictEqual(server.reads.slice(readsBefore), [locked.reference]);
270 + }).pipe(Effect.scoped),
271 + );
272 +
273 + it.effect("a check applies to an instance whose other secret failed a later refresh", () =>
274 + Effect.gen(function* () {
275 + const vault = new Map<string, Array<string | undefined>>([
276 + [wanted.reference, ["wanted-old"]],
277 + [locked.reference, ["locked-key", undefined]],
278 + [other.reference, ["other-key"]],
279 + ]);
280 + const server = yield* setup(vault, [wanted, locked]);
281 + // A Settings refresh while the vault is locked keeps the live instance and caches the failure.
282 + yield* server.mutator.reloadSecrets(dependent);
283 + vault.set(wanted.reference, ["wanted-new"]);
284 +
285 + assert.deepStrictEqual(yield* server.secretCheck.check(wanted), { _tag: "Resolved" });
286 +
287 + assert.deepStrictEqual(server.created.at(-1), {
288 + instanceId: dependent,
289 + secrets: ["wanted-new", "locked-key"],
290 + });
291 + assert.deepStrictEqual(yield* server.registry.listUnavailable, []);
292 + }).pipe(Effect.scoped),
293 + );
294 +
295 + it.effect("a check applies the value it read when a refresh re-reads that secret first", () =>
296 + Effect.forEach(
297 + // A live instance holding the old value, and one parked on a locked vault.
298 + ["wanted-old", undefined],
299 + (initial) =>
300 + Effect.gen(function* () {
301 + const vault = new Map<string, Array<string | undefined>>([
302 + [wanted.reference, [initial]],
303 + [other.reference, ["other-key"]],
304 + ]);
305 + const readStarted = yield* Deferred.make<void>();
306 + const release = yield* Deferred.make<void>();
307 + let gate: Effect.Effect<void> = Effect.void;
308 + const server = yield* setup(vault, [wanted], {
309 + beforeRead: () => {
310 + const current = gate;
311 + gate = Effect.void;
312 + return current;
313 + },
314 + });
315 + // The check reads the rotated value; the refresh's read after it finds the vault locked.
316 + vault.set(wanted.reference, ["wanted-new", undefined]);
317 + gate = Deferred.succeed(readStarted, undefined).pipe(
318 + Effect.andThen(Deferred.await(release)),
319 + );
320 +
321 + const check = yield* server.secretCheck
322 + .check(wanted)
323 + .pipe(Effect.forkChild({ startImmediately: true }));
324 + yield* Deferred.await(readStarted);
325 + // The refresh takes the registry lock, then waits on the resolver for the check's read.
326 + const refresh = yield* server.mutator
327 + .reloadSecrets(dependent)
328 + .pipe(Effect.forkChild({ startImmediately: true }));
329 + yield* Deferred.succeed(release, undefined);
330 +
331 + assert.deepStrictEqual(yield* Fiber.join(check), { _tag: "Resolved" });
332 + yield* Fiber.join(refresh);
333 + assert.deepStrictEqual(server.created.at(-1), {
334 + instanceId: dependent,
335 + secrets: ["wanted-new"],
336 + });
337 + assert.deepStrictEqual(yield* server.registry.listUnavailable, []);
338 + }).pipe(Effect.scoped),
339 + { discard: true },
340 + ),
341 + );
342 +
343 + it.effect("a check replaces only its own key of a record-valued config secret", () =>
344 + Effect.gen(function* () {
345 + const vault = new Map<string, Array<string | undefined>>([
346 + [wanted.reference, ["wanted-old"]],
347 + [locked.reference, ["locked-key"]],
348 + [other.reference, ["other-key"]],
349 + ]);
350 + const server = yield* setup(vault, [], {
351 + dependentConfig: { keys: { a: wanted, b: locked } },
352 + });
353 + vault.set(wanted.reference, ["wanted-new"]);
354 +
355 + assert.deepStrictEqual(yield* server.secretCheck.check(wanted), { _tag: "Resolved" });
356 +
357 + assert.deepStrictEqual(server.created.at(-1), { instanceId: dependent, secrets: [] });
358 + assert.deepStrictEqual(server.createdConfigs.at(-1), {
359 + keys: { a: "wanted-new", b: "locked-key" },
360 + });
361 + }).pipe(Effect.scoped),
362 + );
363 +});
apps/server/src/secrets/SecretCheck.ts new
+39
@@ -0,0 +1,39 @@
1 +import type { SecretReference, SecretSourceCheckResult } from "@t3tools/contracts";
2 +import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver";
3 +import * as Context from "effect/Context";
4 +import * as Effect from "effect/Effect";
5 +import * as Layer from "effect/Layer";
6 +
7 +import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
8 +
9 +export class SecretCheck extends Context.Service<
10 + SecretCheck,
11 + {
12 + /**
13 + * Reads one secret fresh for the Settings "check" button and never returns the value. A
14 + * readable secret also rebuilds the provider instances that read it, from that same read.
15 + */
16 + readonly check: (reference: SecretReference) => Effect.Effect<SecretSourceCheckResult>;
17 + }
18 +>()("t3/secrets/SecretCheck") {}
19 +
20 +const make = Effect.gen(function* () {
21 + const resolver = yield* SecretResolver.SecretResolver;
22 + const providerRegistry = yield* ProviderRegistry.ProviderRegistry;
23 +
24 + const check = Effect.fn("SecretCheck.check")(function* (reference: SecretReference) {
25 + const [value] = yield* resolver.read([reference], { fresh: true });
26 + if (value === undefined || value.trim() === "") {
27 + return {
28 + _tag: "Failed",
29 + detail: `Could not read this secret from "${yield* resolver.label(reference.provider)}". Check the provider's settings and that its store is unlocked.`,
30 + } as const;
31 + }
32 + yield* providerRegistry.applySecretAndRefresh(reference, value);
33 + return { _tag: "Resolved" } as const;
34 + });
35 +
36 + return SecretCheck.of({ check });
37 +});
38 +
39 +export const layer = Layer.effect(SecretCheck, make);
apps/server/src/server.ts
+2
@@ -74,6 +74,7 @@ import * as SourceControlBuiltInDrivers from "./sourceControl/builtInDrivers.ts"
74 import * as SourceControlSignIn from "./sourceControl/SourceControlSignIn.ts";
75 import { BUILT_IN_SOURCE_CONTROL_DRIVER_LIST } from "./sourceControl/sourceControlDefinitions.ts";
76 import * as TextGeneration from "./textGeneration/TextGeneration.ts";
77 +import * as SecretCheck from "./secrets/SecretCheck.ts";
78 import * as SecretResolver from "./secrets/SecretResolver.ts";
79 import * as ProviderInstanceRegistryHydration from "./provider/ProviderInstanceRegistryHydration.ts";
80 import * as ProjectSettingsOverrideSweep from "./provider/ProjectSettingsOverrideSweep.ts";
@@ -691,6 +692,7 @@ const layerRuntimeCoreDependenciesBase = Layer.mergeAll(
692 Layer.provideMerge(layerOrchestrationApplication),
693 Layer.provideMerge(RuntimeLayer.layerEventInfrastructure),
694 Layer.provideMerge(Layer.merge(ProjectStore.layer, ThreadSearch.layer)),
695 + Layer.provideMerge(SecretCheck.layer),
696 Layer.provideMerge(SecretResolver.layer),
697 Layer.provideMerge(layerServerSettings),
698 Layer.provideMerge(layerSourceControlProviderRegistry),
apps/server/src/ws.test.ts
+2
@@ -135,6 +135,7 @@ import * as TriageService from "./triage/TriageService.ts";
135 import * as TextGenerators from "./textGeneration/TextGenerators.ts";
136 import * as WorkspacePaths from "./workspace/WorkspacePaths.ts";
137 import * as ServerSecretStore from "./auth/ServerSecretStore.ts";
138 +import * as SecretCheck from "./secrets/SecretCheck.ts";
139 import * as ServerConfigModule from "./config.ts";
140 import * as Keybindings from "./keybindings.ts";
141 import { USAGE_LIMITS_COMMAND } from "@t3tools/shared/usageLimits";
@@ -790,6 +791,7 @@ it.effect("shell snapshots omit idle children and older settled threads only on
791 const layerUnusedConfigRpcServices = Layer.mergeAll(
792 Layer.mock(DocumentText.DocumentText)({}),
793 Layer.mock(ServerSecretStore.ServerSecretStore)({}),
794 + Layer.mock(SecretCheck.SecretCheck)({}),
795 Layer.mock(WorkspacePaths.WorkspacePaths)({}),
796 Layer.mock(TraceDiagnostics.TraceDiagnostics)({}),
797 Layer.mock(TriageService.TriageService)({}),
apps/server/src/ws.ts
+3
@@ -173,6 +173,7 @@ import * as ThreadSearch from "./orchestration-v2/ThreadSearch.ts";
173 import * as OrchestrationEventStore from "./persistence/OrchestrationEventStore.ts";
174 import { userFacingDispatchErrorMessage } from "./orchestration-v2/UserFacingErrors.ts";
175 import * as ProviderRegistry from "./provider/ProviderRegistry.ts";
176 +import * as SecretCheck from "./secrets/SecretCheck.ts";
177 import * as AcpRegistrySessions from "./provider/AcpRegistrySessions.ts";
178 import * as ProviderInstanceRegistry from "./provider/ProviderInstanceRegistry.ts";
179 import * as AcpRegistrySupport from "@t3tools/provider-acp-registry/server/AcpRegistrySupport";
@@ -1556,6 +1557,7 @@ export const layerWsRpc = (
1557 );
1558 const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
1559 const sourceControlDiscovery = yield* SourceControlDiscovery.SourceControlDiscovery;
1560 + const secretCheck = yield* SecretCheck.SecretCheck;
1561 const otlpEndpointCheck = yield* OtlpEndpointCheck.OtlpEndpointCheck;
1562 const textGenerators = yield* TextGenerators.TextGenerators;
1563 const sourceControlRepositories =
@@ -2661,6 +2663,7 @@ export const layerWsRpc = (
2663 return ServerSettings.redactServerSettingsForClient(settings, settingsClient);
2664 }),
2665 [WS_METHODS.serverDiscoverSourceControl]: (_input) => sourceControlDiscovery.discover,
2666 + [WS_METHODS.serverCheckSecretSource]: (input) => secretCheck.check(input.source),
2667 [WS_METHODS.serverGetTraceDiagnostics]: (_input) =>
2668 TraceDiagnostics.readTraceDiagnostics({
2669 traceFilePath: config.serverTracePath,
apps/web/src/components/settings/AddProviderInstanceDialog.tsx
+1
@@ -552,6 +552,7 @@ export function AddProviderInstanceDialog({
552 environment={localEnvironment}
553 onChange={setLocalEnvironment}
554 secretSources={secretSources}
555 + environmentId={environmentId}
556 />
557 ) : null}
558 </SettingsGroup>
apps/web/src/components/settings/AddUsageLimitSourceDialog.tsx
+1
@@ -107,6 +107,7 @@ export function AddUsageLimitSourceDialog({
107 aria-label="Management key"
108 value={keyDraft}
109 sources={secretSources}
110 + environmentId={environmentId}
111 onChange={(event) => setKeyDraft(event.target.value)}
112 onSecretChange={(secret) => setKeyDraft(secret ?? "")}
113 onValidityChange={setKeyValid}
apps/web/src/components/settings/EasDeviceHostEditor.tsx
+1
@@ -213,6 +213,7 @@ export function EasDeviceHostEditor(props: {
213 : ""
214 }
215 sources={secretSources}
216 + environmentId={props.environmentId}
217 onValidityChange={(valid) => {
218 setTokenValid(valid);
219 resetAccount();
apps/web/src/components/settings/ProviderInstanceCard.tsx
+6
@@ -285,6 +285,7 @@ function ProviderEnvironmentFieldRow(props: {
285 readonly onRemove: (field: ProviderEnvironmentField) => void;
286 readonly managedReason?: string | undefined;
287 readonly secretSources: ReadonlyArray<SecretSource>;
288 + readonly environmentId?: EnvironmentId | undefined;
289 }) {
290 const inputId = `${props.idPrefix}-environment-${props.field.name}`;
291 const value = props.variable?.valueRedacted ? "" : (props.variable?.value ?? "");
@@ -319,6 +320,7 @@ function ProviderEnvironmentFieldRow(props: {
320 spellCheck={false}
321 aria-label={props.field.label}
322 sources={props.secretSources}
323 + environmentId={props.environmentId}
324 onSecretChange={(secret) => props.onSecretChange(props.field, secret)}
325 />
326 )}
@@ -345,6 +347,7 @@ export function ProviderEnvironmentSection(props: {
347 /** Variables an administrator's policy pins: listed by name, never editable or removable. */
348 readonly managed?: { readonly names: ReadonlySet<string>; readonly reason: string } | undefined;
349 readonly secretSources?: ReadonlyArray<SecretSource>;
350 + readonly environmentId?: EnvironmentId | undefined;
351 }) {
352 const [storedDraft, setDraft] = useState(() =>
353 seedRowsDraft(props.environment, toEnvironmentDraftRows),
@@ -546,6 +549,7 @@ export function ProviderEnvironmentSection(props: {
549 spellCheck={false}
550 aria-label={`Environment variable value ${index + 1}`}
551 sources={props.secretSources ?? []}
552 + environmentId={props.environmentId}
553 onSecretChange={(secret) => setVariableSecret(variable.id, secret)}
554 >
555 {(parts) => layout(parts.source, parts.value)}
@@ -1328,6 +1332,7 @@ export function ProviderInstanceCard({
1332 : undefined
1333 }
1334 secretSources={secretSources}
1335 + environmentId={environmentId}
1336 />
1337 ))}
1338 </div>
@@ -1375,6 +1380,7 @@ export function ProviderInstanceCard({
1380 environment={genericEnvironment}
1381 onChange={updateGenericEnvironment}
1382 secretSources={secretSources}
1383 + environmentId={environmentId}
1384 managed={
1385 instanceLocks && {
1386 names: instanceLocks.environmentNames,
apps/web/src/components/settings/ProviderSettingsForm.tsx
+1
@@ -383,6 +383,7 @@ function SecretSettingsControl({
383 value={reference ?? ""}
384 configured={reference === undefined && configured}
385 sources={sources}
386 + environmentId={environmentId}
387 onCommit={(next) => onChange(nextProviderConfigWithFieldValue(value, field, next))}
388 onSecretChange={(secret) =>
389 onChange(nextProviderConfigWithFieldValue(value, field, secret ?? ""))
apps/web/src/components/settings/SecretSourceInput.tsx
+140 -32
@@ -9,15 +9,19 @@ import { builtInSecretProviderDefinitions } from "@t3tools/secret-provider-defin
9 import { useAtomValue } from "@effect/atom-react";
10 import * as Option from "effect/Option";
11 import * as Schema from "effect/Schema";
12 -import { KeyRoundIcon, TypeIcon } from "lucide-react";
12 +import { AlertTriangleIcon, CheckIcon, KeyRoundIcon, RefreshCwIcon, TypeIcon } from "lucide-react";
13 import { useState, type ComponentProps, type ComponentType, type ReactNode } from "react";
14
15 import { isSecretsFeatureEnabled } from "../../env";
16 import { useEnvironmentSettings } from "../../hooks/useSettings";
17 import { OnePasswordIcon } from "../Icons";
18 import { serverEnvironment } from "../../state/server";
19 +import { useAtomCommand } from "../../state/use-atom-command";
20 +import { Button } from "../ui/button";
21 import { DraftInput } from "../ui/draft-input";
22 import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../ui/select";
23 +import { Spinner } from "../ui/spinner";
24 +import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
25 import { SecretInput } from "./SecretInput";
26 import { classifySecretProvider } from "./SecretProviderDialog.logic";
27
@@ -111,8 +115,97 @@ export function SecretSourceSelect(props: {
115 );
116 }
117
118 +type SecretCheck =
119 + | { readonly status: "checking" }
120 + | { readonly status: "resolved" }
121 + | { readonly status: "failed"; readonly detail: string };
122 +
123 +/** Asks the server to resolve the committed reference, so a typo shows here and not at provider start. */
124 +function SecretCheckButton(props: {
125 + readonly environmentId: EnvironmentId;
126 + readonly secret: SecretReference;
127 + readonly label: string;
128 + readonly disabled?: boolean | undefined;
129 +}) {
130 + const { environmentId, secret } = props;
131 + const supported = useAtomValue(
132 + serverEnvironment.configValueAtom(environmentId),
133 + (config) => config?.environment.capabilities.secretSourceCheck === true,
134 + );
135 + const canCheck = useAtomValue(serverEnvironment.checkSecretSource.permissionAtom(environmentId));
136 + const checkSecretSource = useAtomCommand(serverEnvironment.checkSecretSource);
137 + const secretKey = `${secret.provider}\u0000${secret.reference}`;
138 + const [check, setCheck] = useState<{
139 + readonly secretKey: string;
140 + readonly state: SecretCheck;
141 + } | null>(null);
142 + const state = check?.secretKey === secretKey ? check.state : undefined;
143 +
144 + const run = async () => {
145 + setCheck({ secretKey, state: { status: "checking" } });
146 + const response = await checkSecretSource({ environmentId, input: { source: secret } });
147 + const next: SecretCheck =
148 + response._tag !== "Success"
149 + ? { status: "failed", detail: "Could not reach the server" }
150 + : response.value._tag === "Resolved"
151 + ? { status: "resolved" }
152 + : { status: "failed", detail: response.value.detail };
153 + setCheck((previous) =>
154 + previous?.secretKey === secretKey ? { secretKey, state: next } : previous,
155 + );
156 + };
157 +
158 + if (!supported) return null;
159 + const description = !canCheck
160 + ? "You cannot check secrets on this environment"
161 + : state === undefined
162 + ? "Check that the secret resolves"
163 + : state.status === "checking"
164 + ? "Checking the secret"
165 + : state.status === "resolved"
166 + ? "Secret resolved"
167 + : state.detail;
168 + return (
169 + <Tooltip>
170 + <TooltipTrigger
171 + render={
172 + <span className="inline-flex">
173 + <Button
174 + type="button"
175 + size="icon-micro"
176 + variant="ghost-muted"
177 + disabled={props.disabled === true || !canCheck || state?.status === "checking"}
178 + onClick={() => void run()}
179 + aria-label={
180 + state?.status === "failed"
181 + ? `${props.label} failed: ${state.detail}`
182 + : state?.status === "resolved"
183 + ? `${props.label} resolved`
184 + : props.label
185 + }
186 + >
187 + {state?.status === "checking" ? (
188 + <Spinner />
189 + ) : state?.status === "resolved" ? (
190 + <CheckIcon className="text-success-foreground" />
191 + ) : state?.status === "failed" ? (
192 + <AlertTriangleIcon className="text-destructive" />
193 + ) : (
194 + <RefreshCwIcon />
195 + )}
196 + </Button>
197 + </span>
198 + }
199 + />
200 + <TooltipPopup side="top">{description}</TooltipPopup>
201 + </Tooltip>
202 + );
203 +}
204 +
205 type SecretSourceInputProps = Omit<ComponentProps<typeof SecretInput>, "value" | "children"> & {
206 readonly value: string | SecretReference;
207 + /** Offers a check of the committed reference on this environment. */
208 + readonly environmentId?: EnvironmentId | undefined;
209 readonly sources: ReadonlyArray<SecretSource>;
210 readonly onSecretChange: (secret: SecretReference | undefined) => void;
211 /** Whether the selected source and committed field can be saved or used. */
@@ -127,6 +220,7 @@ type SecretSourceInputProps = Omit<ComponentProps<typeof SecretInput>, "value" |
220 /** A secret entered here, or read from a secret provider when one is configured. */
221 export function SecretSourceInput({
222 value,
223 + environmentId,
224 sources,
225 onSecretChange,
226 onValidityChange,
@@ -168,38 +262,52 @@ export function SecretSourceInput({
262 <SecretInput {...input} />
263 ) : (
264 <div className="flex min-w-0 flex-1 flex-col gap-1">
171 - <DraftInput
172 - {...(input.id !== undefined ? { id: input.id } : {})}
173 - size="sm"
174 - font="mono"
175 - value={rejectedReference ?? reference}
176 - onCommit={(next) => {
177 - if (next.trim().length === 0) {
265 + <div className="flex min-w-0 items-center gap-1.5">
266 + <DraftInput
267 + {...(input.id !== undefined ? { id: input.id } : {})}
268 + size="sm"
269 + font="mono"
270 + className="min-w-0 flex-1"
271 + value={rejectedReference ?? reference}
272 + onCommit={(next) => {
273 + if (next.trim().length === 0) {
274 + setRejectedReference(null);
275 + onValidityChange?.(pendingProvider === null && secret !== undefined);
276 + if (pendingProvider === null && secret !== undefined) onSecretChange(undefined);
277 + return;
278 + }
279 + const decoded = decodeSecretReference({ provider, reference: next });
280 + if (
281 + Option.isNone(decoded) ||
282 + definition?.isReference(decoded.value.reference) === false
283 + ) {
284 + setRejectedReference(next);
285 + onValidityChange?.(false);
286 + return;
287 + }
288 setRejectedReference(null);
179 - onValidityChange?.(pendingProvider === null && secret !== undefined);
180 - if (pendingProvider === null && secret !== undefined) onSecretChange(undefined);
181 - return;
182 - }
183 - const decoded = decodeSecretReference({ provider, reference: next });
184 - if (
185 - Option.isNone(decoded) ||
186 - definition?.isReference(decoded.value.reference) === false
187 - ) {
188 - setRejectedReference(next);
189 - onValidityChange?.(false);
190 - return;
191 - }
192 - setRejectedReference(null);
193 - setPendingProvider(null);
194 - onValidityChange?.(true);
195 - onSecretChange(decoded.value);
196 - }}
197 - autoComplete="off"
198 - placeholder={definition?.referencePlaceholder}
199 - spellCheck={false}
200 - aria-label={`${label} reference`}
201 - aria-invalid={rejectedReference !== null}
202 - />
289 + setPendingProvider(null);
290 + onValidityChange?.(true);
291 + onSecretChange(decoded.value);
292 + }}
293 + autoComplete="off"
294 + placeholder={definition?.referencePlaceholder}
295 + spellCheck={false}
296 + aria-label={`${label} reference`}
297 + aria-invalid={rejectedReference !== null}
298 + />
299 + {environmentId !== undefined &&
300 + secret !== undefined &&
301 + pendingProvider === null &&
302 + rejectedReference === null ? (
303 + <SecretCheckButton
304 + environmentId={environmentId}
305 + secret={secret}
306 + label={`Check ${label}`}
307 + disabled={input.disabled}
308 + />
309 + ) : null}
310 + </div>
311 {rejectedReference !== null ? (
312 <p className="text-2xs text-destructive">
313 {definition?.invalidReferenceMessage ?? "Enter a valid secret reference."}
apps/web/src/components/settings/SimlockDeviceHostEditor.tsx
+1
@@ -301,6 +301,7 @@ function SimlockTokenField(props: {
301 key={inputKey}
302 id={id}
303 aria-label="Agent token"
304 + environmentId={props.environmentId}
305 className="min-w-0 flex-1"
306 configured={props.token.kind === "saved" && typeof props.saved === "string"}
307 value={
apps/web/src/components/settings/SourceControlTokenSettings.tsx
+1
@@ -127,6 +127,7 @@ export function SourceControlTokenSettings({
127 id={`${definition.kind}-token-${environmentId}`}
128 size="sm"
129 aria-label={`${definition.label} token`}
130 + environmentId={environmentId}
131 configured={isSaved && !isSecretReference(savedToken)}
132 value={draft}
133 sources={secretSources}
docs/user/secrets.md
+2
@@ -29,6 +29,8 @@ Credential fields in Settings, such as provider environment variables and creden
29 control tokens, usage limit keys, and device host tokens, show a source picker next to the field.
30 Pick **Value** to save the credential itself, or pick a secret provider and enter a reference such
31 as `op://vault/item/field`. Copy the reference from 1Password with **Copy Secret Reference**.
32 +Select the check button next to a reference to read it now. If it reads, providers that use it
33 +start using the new value.
34
35 T3 Code reads the secret when it needs it, for example when a provider starts. Change the
36 credential in 1Password and refresh to use the new value.
packages/client-runtime/src/state/commandPermissions.test.ts
+21 -19
@@ -183,25 +183,27 @@ describe("command permissions", () => {
183 ),
184 );
185
186 - it.effect("requires the destination settings grant to check OTLP endpoints", () =>
187 - Effect.scoped(
188 - Effect.gen(function* () {
189 - const registry = yield* setup;
190 - const check = createCommandPermissions(runtime, WS_METHODS.serverCheckOtlpEndpoint);
191 - registry.set(sessions(env), AsyncResult.success(grant(true)));
192 - expect(registry.get(check.permissionAtom(env))).toBe(false);
193 - registry.set(
194 - sessions(env),
195 - AsyncResult.success({
196 - ...grant(false),
197 - scopes: [AuthSettingsWriteScope],
198 - permissions: [AuthSettingsWriteScope],
199 - }),
200 - );
201 - expect(registry.get(check.permissionAtom(env))).toBe(true);
202 - yield* check.authorize(registry, env);
203 - }),
204 - ),
186 + it.effect.each([WS_METHODS.serverCheckOtlpEndpoint, WS_METHODS.serverCheckSecretSource])(
187 + "requires the destination settings grant for %s",
188 + (method) =>
189 + Effect.scoped(
190 + Effect.gen(function* () {
191 + const registry = yield* setup;
192 + const check = createCommandPermissions(runtime, method);
193 + registry.set(sessions(env), AsyncResult.success(grant(true)));
194 + expect(registry.get(check.permissionAtom(env))).toBe(false);
195 + registry.set(
196 + sessions(env),
197 + AsyncResult.success({
198 + ...grant(false),
199 + scopes: [AuthSettingsWriteScope],
200 + permissions: [AuthSettingsWriteScope],
201 + }),
202 + );
203 + expect(registry.get(check.permissionAtom(env))).toBe(true);
204 + yield* check.authorize(registry, env);
205 + }),
206 + ),
207 );
208
209 it.effect.each([WS_METHODS.scheduledTasksDelete, ORCHESTRATION_V2_WS_METHODS.stopWorkflow])(
packages/client-runtime/src/state/server.ts
+4
@@ -1810,6 +1810,10 @@ export function createServerEnvironmentAtoms<R, E>(
1810 label: "environment-data:server:check-otlp-endpoint",
1811 tag: WS_METHODS.serverCheckOtlpEndpoint,
1812 }),
1813 + checkSecretSource: createEnvironmentRpcCommand(runtime, {
1814 + label: "environment-data:server:check-secret-source",
1815 + tag: WS_METHODS.serverCheckSecretSource,
1816 + }),
1817 listTextGeneratorModels: createEnvironmentRpcCommand(runtime, {
1818 label: "environment-data:server:list-text-generator-models",
1819 tag: WS_METHODS.serverListTextGeneratorModels,
packages/contracts/src/clientRpcPermissions.ts
+1
@@ -25,6 +25,7 @@ export const CLIENT_GUARDED_RPC_SCOPES = {
25 // Restarts the server, as an update does.
26 [WS_METHODS.serverReclaimDatabaseSpace]: AuthEnvironmentMaintainScope,
27 [WS_METHODS.serverCheckOtlpEndpoint]: AuthSettingsWriteScope,
28 + [WS_METHODS.serverCheckSecretSource]: AuthSettingsWriteScope,
29 // Listing models spends the stored API key, so only those who can choose a model may.
30 [WS_METHODS.serverListTextGeneratorModels]: AuthSettingsWriteScope,
31 [WS_METHODS.serverRefreshProviders]: AuthOrchestrationReadScope,
packages/contracts/src/environment.ts
+2
@@ -98,6 +98,8 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({
98 storageCleanupRun: Schema.optionalKey(Schema.Boolean),
99 databaseStorage: Schema.optionalKey(Schema.Boolean),
100 otlpEndpointCheck: Schema.optionalKey(Schema.Boolean),
101 + /** Serves `server.checkSecretSource`; hide the secret check where it is absent. */
102 + secretSourceCheck: Schema.optionalKey(Schema.Boolean),
103 projectWorktreeCleanup: Schema.optionalKey(Schema.Boolean),
104 settledWorktreeCleanup: Schema.optionalKey(Schema.Boolean),
105 worktreesDirectory: Schema.optionalKey(Schema.Boolean),
packages/contracts/src/rpc.ts
+10
@@ -38,6 +38,8 @@ import * as Rpc from "effect/rpc/Rpc";
38 import * as RpcGroup from "effect/rpc/RpcGroup";
39 import * as RpcMiddleware from "effect/rpc/RpcMiddleware";
40 import { NonNegativeInt, TrimmedNonEmptyString } from "./baseSchemas.ts";
41 +import { SecretSourceCheckResult } from "./settingsSecretValue.ts";
42 +import { SecretReference } from "./secretReference.ts";
43 import {
44 ProviderAuthCancelInput,
45 ProviderAuthCompleteInput,
@@ -523,6 +525,7 @@ export const WS_METHODS = {
525 peerLinksAnswerRequest: "peerLinks.answerRequest",
526 serverUpdateSettings: "server.updateSettings",
527 serverDiscoverSourceControl: "server.discoverSourceControl",
528 + serverCheckSecretSource: "server.checkSecretSource",
529 serverSearchAcpRegistry: "server.searchAcpRegistry",
530 serverPrepareAcpRegistryAgent: "server.prepareAcpRegistryAgent",
531 serverUninstallAcpRegistryManagedBinary: "server.uninstallAcpRegistryManagedBinary",
@@ -875,6 +878,12 @@ const WsServerDiscoverSourceControlRpc = Rpc.make(WS_METHODS.serverDiscoverSourc
878 error: EnvironmentAuthorizationError,
879 });
880
881 +const WsServerCheckSecretSourceRpc = Rpc.make(WS_METHODS.serverCheckSecretSource, {
882 + payload: Schema.Struct({ source: SecretReference }),
883 + success: SecretSourceCheckResult,
884 + error: EnvironmentAuthorizationError,
885 +});
886 +
887 const WsServerSearchAcpRegistryRpc = Rpc.make(WS_METHODS.serverSearchAcpRegistry, {
888 payload: AcpRegistrySearchInput,
889 success: AcpRegistrySearchResult,
@@ -2118,6 +2127,7 @@ export const WsRpcGroup = RpcGroup.make(
2127 WsPeerLinksUnlinkRpc,
2128 WsPeerLinksAnswerRequestRpc,
2129 WsServerDiscoverSourceControlRpc,
2130 + WsServerCheckSecretSourceRpc,
2131 WsServerSearchAcpRegistryRpc,
2132 WsServerPrepareAcpRegistryAgentRpc,
2133 WsServerUninstallAcpRegistryManagedBinaryRpc,
packages/contracts/src/settingsSecretValue.ts
+6
@@ -121,3 +121,9 @@ export function withSettingsSecrets<Settings extends Readonly<Record<string, unk
121 }
122 return next as Settings;
123 }
124 +
125 +export const SecretSourceCheckResult = Schema.Union([
126 + Schema.TaggedStruct("Resolved", {}),
127 + Schema.TaggedStruct("Failed", { detail: Schema.String }),
128 +]);
129 +export type SecretSourceCheckResult = typeof SecretSourceCheckResult.Type;
packages/secret-provider-core/src/server/SecretResolver.ts
+20 -5
@@ -1,6 +1,6 @@
1 // Reads secrets that settings point at through a configured secret provider. Each read, including
2 // a failed one, is held for the server's life so rebuilds never re-prompt an unlock; `invalidate`
3 -// (the Settings refresh) is the only way to read again.
3 +// (the Settings refresh) and a `fresh` read are the only ways to read again.
4 import type { SecretReference, ServerSettings } from "@t3tools/contracts";
5 import * as Context from "effect/Context";
6 import * as Effect from "effect/Effect";
@@ -14,9 +14,14 @@ import type { SecretProviderDriver, SecretProviderDriverServices } from "./drive
14 export class SecretResolver extends Context.Service<
15 SecretResolver,
16 {
17 - /** Values in input order; `undefined` marks a reference that could not be read. */
17 + /**
18 + * Values in input order; `undefined` marks a reference that could not be read. `fresh` asks the
19 + * provider again and returns what it answered, but an unreadable or empty answer does not
20 + * replace a value that is already held.
21 + */
22 readonly read: (
23 references: ReadonlyArray<SecretReference>,
24 + options?: { readonly fresh?: boolean },
25 ) => Effect.Effect<ReadonlyArray<string | undefined>>;
26 /** Forgets the given references, or every reference, so the next read asks the provider again. */
27 readonly invalidate: (references?: ReadonlyArray<SecretReference>) => Effect.Effect<void>;
@@ -90,12 +95,14 @@ export const make = Effect.fn("SecretResolver.make")(function* (options: {
95 // Cache hits answer without the lock, so a read waiting on an unlock never stalls a cached one.
96 const read: SecretResolver["Service"]["read"] = Effect.fn("SecretResolver.read")(function* (
97 references,
98 + readOptions,
99 ) {
100 + const fresh = readOptions?.fresh === true;
101 const providers = yield* options.secretProviders;
102 const plans = references.map((reference) => planFor(providers, reference));
103 const isMissing = (reference: SecretReference, index: number) => {
104 const plan = plans[index];
98 - return plan !== undefined && !isCached(reference, plan);
105 + return plan !== undefined && (fresh || !isCached(reference, plan));
106 };
107 if (!references.some(isMissing)) return answer(references, plans);
108
@@ -118,15 +125,23 @@ export const make = Effect.fn("SecretResolver.make")(function* (options: {
125 ]);
126 wanted.set(reference.provider, group);
127 });
128 + const answered = new Map<string, string | undefined>();
129 for (const { plan, byReference } of wanted.values()) {
130 const values = yield* plan.driver.read(plan.config, [...byReference.keys()]);
131 [...byReference.values()].forEach((sameReference, index) => {
132 + const value = values[index];
133 + const readable = value !== undefined && value.trim() !== "";
134 for (const reference of sameReference) {
125 - cache.set(cacheKey(reference), { config: plan.configKey, value: values[index] });
135 + answered.set(cacheKey(reference), value);
136 + if (!fresh || readable || !isCached(reference, plan)) {
137 + cache.set(cacheKey(reference), { config: plan.configKey, value });
138 + }
139 }
140 });
141 }
129 - return answer(references, plans);
142 + return fresh
143 + ? references.map((reference) => answered.get(cacheKey(reference)))
144 + : answer(references, plans);
145 }),
146 );
147 }, Effect.provideContext(context));