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));