The best way to control Claude Code, Codex and more from any computer or phone
fix(server): a settings save no longer reads an unreadable secret again (#31226)
Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>
Yordis Prieto committed
Nov 5, 2026 at 13:47 UTC
edeea8cd67e6cce673a58c643cb2dd4fdce3c858
4 files changed
+140
-9
apps/server/src/provider/ProviderInstanceRegistry.test.ts
+8
-2
@@ -878,7 +878,7 @@ describe("ProviderInstanceRegistry secret environment", () => {
878
yield* PubSub.take(changes);
879
return built;
880
});
881
- return { vault, reads, invalidated, created, configs, make, makeGated, gate };
881
+ return { vault, reads, invalidated, created, configs, configMap, make, makeGated, gate };
882
}
883
884
it.effect("starts an instance with the secret its environment points at", () => {
@@ -899,13 +899,19 @@ describe("ProviderInstanceRegistry secret environment", () => {
899
it.effect("marks an instance unavailable and names the variable it could not read", () => {
900
const fixture = setup({});
901
return Effect.gen(function* () {
902
- const { registry } = yield* fixture.make;
902
+ const { registry, mutator } = yield* fixture.make;
903
+ const readsAtStartup = fixture.reads.length;
904
905
expect(yield* registry.getInstance(instanceId)).toBeUndefined();
906
expect(fixture.created).toEqual([]);
907
const [unavailable] = yield* registry.listUnavailable;
908
expect(unavailable?.instanceId).toBe(instanceId);
909
expect(unavailable?.unavailableReason).toContain("OPENAI_API_KEY");
910
+
911
+ // A settings save that leaves it alone does not read the vault again.
912
+ yield* mutator.reconcile({ ...fixture.configMap });
913
+ expect(fixture.reads).toHaveLength(readsAtStartup);
914
+ expect(yield* registry.listUnavailable).toHaveLength(1);
915
}).pipe(Effect.scoped);
916
});
917
apps/server/src/provider/ProviderInstanceRegistry.ts
+37
-4
@@ -60,6 +60,9 @@ interface LiveEntry {
60
interface RegistryState {
61
readonly entries: Ref.Ref<ReadonlyMap<ProviderInstanceId, LiveEntry>>;
62
readonly unavailable: Ref.Ref<ReadonlyMap<ProviderInstanceId, ServerProvider>>;
63
+ // Configs parked on an unreadable secret. A settings save that leaves one alone does not read
64
+ // its vault again, so a locked vault is not prompted for on every unrelated save.
65
+ readonly secretsUnreadable: Ref.Ref<ReadonlyMap<ProviderInstanceId, ProviderInstanceConfig>>;
66
readonly changes: PubSub.PubSub<void>;
67
}
68
@@ -155,7 +158,11 @@ const buildEntry = Effect.fn("ProviderInstanceRegistry.buildEntry")(function* <R
158
readonly deferSecrets: boolean;
159
}): Effect.fn.Return<
160
| { readonly kind: "live"; readonly live: LiveEntry }
158
- | { readonly kind: "unavailable"; readonly snapshot: ServerProvider },
161
+ | {
162
+ readonly kind: "unavailable";
163
+ readonly snapshot: ServerProvider;
164
+ readonly secretsUnreadable?: true;
165
+ },
166
never,
167
R | SecretResolver.SecretResolver
168
> {
@@ -234,6 +241,7 @@ const buildEntry = Effect.fn("ProviderInstanceRegistry.buildEntry")(function* <R
241
if (unreadable.length > 0) {
242
return {
243
kind: "unavailable" as const,
244
+ secretsUnreadable: true as const,
245
snapshot: yield* buildUnavailableProviderSnapshot({
246
driverKind: entry.driver,
247
instanceId,
@@ -304,6 +312,7 @@ const makeReconcile = <R>(input: {
312
Effect.gen(function* () {
313
const previousEntries = yield* Ref.get(state.entries);
314
const previousUnavailable = yield* Ref.get(state.unavailable);
315
+ const previousSecretsUnreadable = yield* Ref.get(state.secretsUnreadable);
316
const nextRaw = Object.entries(configMap);
317
const nextKeys = new Set<ProviderInstanceId>(
318
nextRaw.map(([raw]) => ProviderInstanceId.make(raw)),
@@ -338,12 +347,21 @@ const makeReconcile = <R>(input: {
347
}
348
}
349
350
+ const parkedSnapshot = (instanceId: ProviderInstanceId, entry: ProviderInstanceConfig) => {
351
+ const parked = previousSecretsUnreadable.get(instanceId);
352
+ return !rebuild.has(instanceId) && parked !== undefined && entryEqual(parked, entry)
353
+ ? previousUnavailable.get(instanceId)
354
+ : undefined;
355
+ };
356
+
357
// Read every secret the builds below need in one go, so a vault unlocks once.
358
const references = yield* Effect.forEach(nextRaw, ([rawInstanceId, entry]) =>
359
Effect.gen(function* () {
360
const instanceId = ProviderInstanceId.make(rawInstanceId);
361
const kept = previousEntries.has(instanceId) && !replacedIds.has(instanceId);
346
- return kept || !(yield* isEntryEnabled(driversById, entry))
362
+ return kept ||
363
+ parkedSnapshot(instanceId, entry) !== undefined ||
364
+ !(yield* isEntryEnabled(driversById, entry))
365
? []
366
: secretReferencesOf(driversById, entry);
367
}),
@@ -354,6 +372,7 @@ const makeReconcile = <R>(input: {
372
373
const builtEntries = new Map<ProviderInstanceId, LiveEntry>();
374
const builtUnavailable = new Map<ProviderInstanceId, ServerProvider>();
375
+ const builtSecretsUnreadable = new Map<ProviderInstanceId, ProviderInstanceConfig>();
376
let orderChanged = false;
377
const previousOrder = [...previousEntries.keys()];
378
const nextOrder: Array<ProviderInstanceId> = [];
@@ -367,6 +386,12 @@ const makeReconcile = <R>(input: {
386
builtEntries.set(instanceId, existing);
387
continue;
388
}
389
+ const parked = parkedSnapshot(instanceId, entry);
390
+ if (parked !== undefined) {
391
+ builtUnavailable.set(instanceId, parked);
392
+ builtSecretsUnreadable.set(instanceId, entry);
393
+ continue;
394
+ }
395
396
const result = yield* buildEntry({
397
driversById,
@@ -381,6 +406,7 @@ const makeReconcile = <R>(input: {
406
builtEntries.set(instanceId, result.live);
407
} else {
408
builtUnavailable.set(instanceId, result.snapshot);
409
+ if (result.secretsUnreadable) builtSecretsUnreadable.set(instanceId, entry);
410
}
411
}
412
@@ -410,6 +436,7 @@ const makeReconcile = <R>(input: {
436
437
yield* Ref.set(state.entries, builtEntries);
438
yield* Ref.set(state.unavailable, builtUnavailable);
439
+ yield* Ref.set(state.secretsUnreadable, builtSecretsUnreadable);
440
441
if (entriesChanged || unavailableChanged) {
442
yield* PubSub.publish(state.changes, undefined);
@@ -446,10 +473,13 @@ export const makeProviderInstanceRegistry = Effect.fn(
473
474
const entries = yield* Ref.make<ReadonlyMap<ProviderInstanceId, LiveEntry>>(new Map());
475
const unavailable = yield* Ref.make<ReadonlyMap<ProviderInstanceId, ServerProvider>>(new Map());
476
+ const secretsUnreadable = yield* Ref.make<
477
+ ReadonlyMap<ProviderInstanceId, ProviderInstanceConfig>
478
+ >(new Map());
479
const changes = yield* PubSub.unbounded<void>();
480
yield* Effect.addFinalizer(() => PubSub.shutdown(changes));
481
452
- const state: RegistryState = { entries, unavailable, changes };
482
+ const state: RegistryState = { entries, unavailable, secretsUnreadable, changes };
483
const reconcileWithR = makeReconcile({
484
state,
485
driversById,
@@ -488,7 +518,10 @@ export const makeProviderInstanceRegistry = Effect.fn(
518
const rebuild = new Set<ProviderInstanceId>();
519
for (const [rawInstanceId, entry] of targets) {
520
const current = live.get(ProviderInstanceId.make(rawInstanceId));
491
- if (current === undefined) continue;
521
+ if (current === undefined) {
522
+ rebuild.add(ProviderInstanceId.make(rawInstanceId));
523
+ continue;
524
+ }
525
const { secrets, unreadable } = yield* readInstanceSecrets(
526
driversById.get(entry.driver),
527
entry,
apps/server/src/provider/ProviderInstanceRegistryHydration.test.ts
+70
@@ -3,12 +3,16 @@ import {
3
ProjectId,
4
ProviderDriverKind,
5
ProviderInstanceId,
6
+ SecretProviderId,
7
+ SecretProviderKind,
8
type ServerSettings,
9
} from "@t3tools/contracts";
10
import * as NodeServices from "@effect/platform-node/NodeServices";
11
import { it as effectIt } from "@effect/vitest";
12
import * as Effect from "effect/Effect";
13
import * as Layer from "effect/Layer";
14
+import * as Queue from "effect/Queue";
15
+import * as Stream from "effect/Stream";
16
import { describe, expect, it } from "vite-plus/test";
17
18
import * as ServerConfig from "../config.ts";
@@ -16,8 +20,10 @@ import { ServerSettingsService } from "../serverSettings.ts";
20
import {
21
DEV_REPLAY_INSTANCE_ID,
22
deriveProviderInstanceConfigMap,
23
+ layerSettingsWatcher,
24
seedDevReplayInstance,
25
} from "./ProviderInstanceRegistryHydration.ts";
26
+import { ProviderInstanceRegistryMutator } from "./ProviderInstanceRegistryMutator.ts";
27
28
const projectId = ProjectId.make("project-a");
29
const instanceId = ProviderInstanceId.make("codex_work");
@@ -141,3 +147,67 @@ describe("seedDevReplayInstance", () => {
147
),
148
);
149
});
150
+
151
+describe("layerSettingsWatcher", () => {
152
+ const provider = (label: string) => ({
153
+ [SecretProviderId.make("personal")]: {
154
+ kind: SecretProviderKind.make("one_password"),
155
+ label,
156
+ config: { account: "my" },
157
+ },
158
+ });
159
+
160
+ const watch = (initial: ServerSettings | undefined) =>
161
+ Effect.gen(function* () {
162
+ const changes = yield* Queue.unbounded<ServerSettings>();
163
+ const reconciled = yield* Queue.unbounded<void>();
164
+ let reloads = 0;
165
+ const mutator = Layer.succeed(ProviderInstanceRegistryMutator, {
166
+ reconcile: () => Queue.offer(reconciled, undefined),
167
+ reloadSecrets: () => Effect.sync(() => void reloads++),
168
+ });
169
+ yield* Layer.build(
170
+ layerSettingsWatcher(Stream.fromQueue(changes), initial).pipe(Layer.provide(mutator)),
171
+ );
172
+ return {
173
+ reloads: () => reloads,
174
+ // Changes run one at a time, so the repeat's reconcile means the first one's reload decision is done.
175
+ change: (settings: ServerSettings) =>
176
+ Queue.offerAll(changes, [settings, settings]).pipe(
177
+ Effect.andThen(Queue.take(reconciled)),
178
+ Effect.andThen(Queue.take(reconciled)),
179
+ ),
180
+ };
181
+ });
182
+
183
+ effectIt.effect(
184
+ "retries unreadable secrets when a secret provider changes, not when it is renamed",
185
+ () =>
186
+ Effect.gen(function* () {
187
+ const settings = yield* ServerSettingsService;
188
+ const { reloads, change } = yield* watch(yield* settings.getSettings);
189
+
190
+ yield* change(yield* settings.updateSettings({ secretProviders: provider("Personal") }));
191
+ expect(reloads()).toBe(1);
192
+
193
+ // A label is not read by any vault, so renaming a provider retries nothing.
194
+ yield* change(yield* settings.updateSettings({ secretProviders: provider("Renamed") }));
195
+ expect(reloads()).toBe(1);
196
+ }).pipe(Effect.scoped, Effect.provide(ServerSettingsService.layerTest())),
197
+ );
198
+
199
+ effectIt.effect(
200
+ "compares a change queued during startup with the settings the registry started from",
201
+ () =>
202
+ Effect.gen(function* () {
203
+ const settings = yield* ServerSettingsService;
204
+ const started = yield* settings.getSettings;
205
+ const saved = yield* settings.updateSettings({ secretProviders: provider("Personal") });
206
+ const { reloads, change } = yield* watch(started);
207
+
208
+ yield* change(saved);
209
+
210
+ expect(reloads()).toBe(1);
211
+ }).pipe(Effect.scoped, Effect.provide(ServerSettingsService.layerTest())),
212
+ );
213
+});
apps/server/src/provider/ProviderInstanceRegistryHydration.ts
+25
-3
@@ -8,6 +8,8 @@ import {
8
type ProviderInstanceConfigMap,
9
ServerSettings,
10
} from "@t3tools/contracts";
11
+import * as NodeUtil from "node:util";
12
+
13
import * as HostProcess from "@t3tools/shared/HostProcess";
14
import type * as SecureRandom from "effect/crypto/SecureRandom";
15
import * as Effect from "effect/Effect";
@@ -122,18 +124,36 @@ export const seedDevReplayInstance = Effect.fn(
124
});
125
});
126
125
-const layerSettingsWatcher = (settingsChanges: Stream.Stream<ServerSettings>) =>
127
+// A label is display-only, so only kind and config can change what a vault returns.
128
+const vaultConfigs = (settings: ServerSettings) =>
129
+ Object.entries(settings.secretProviders).map(([id, { kind, config }]) => [id, kind, config]);
130
+
131
+export const layerSettingsWatcher = (
132
+ settingsChanges: Stream.Stream<ServerSettings>,
133
+ // The settings the registry was built from: a change queued during startup differs from these.
134
+ initialSettings: ServerSettings | undefined,
135
+) =>
136
Layer.effectDiscard(
137
Effect.gen(function* () {
138
const mutator = yield* ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator;
139
const serverSettings = yield* Settings.ServerSettingsService;
140
+ let secretProviders = initialSettings && vaultConfigs(initialSettings);
141
yield* settingsChanges.pipe(
142
Stream.runForEach(() =>
143
// The subscription predates the seed read, so a queued change can be
144
// older than the seed. A failed current read must leave the registry intact.
145
serverSettings.getSettings.pipe(
146
Effect.flatMap((current) =>
136
- mutator.reconcile(deriveProviderInstanceConfigMap(current)),
147
+ Effect.gen(function* () {
148
+ yield* mutator.reconcile(deriveProviderInstanceConfigMap(current));
149
+ // Reconcile leaves instances parked on an unreadable secret alone,
150
+ // and a corrected secret provider is what can make them readable.
151
+ const next = vaultConfigs(current);
152
+ if (!NodeUtil.isDeepStrictEqual(secretProviders, next)) {
153
+ secretProviders = next;
154
+ yield* mutator.reloadSecrets();
155
+ }
156
+ }),
157
),
158
Effect.catchCause((cause) =>
159
Effect.logError("ProviderInstanceRegistry reconcile failed", cause),
@@ -186,7 +206,9 @@ export const layer: Layer.Layer<
206
Layer.provide(SecretResolver.layer),
207
);
208
189
- return layerSettingsWatcher(settingsChanges).pipe(Layer.provideMerge(layerMutable));
209
+ return layerSettingsWatcher(settingsChanges, initialSettings).pipe(
210
+ Layer.provideMerge(layerMutable),
211
+ );
212
}),
213
) as Layer.Layer<
214
| ProviderInstanceRegistry.ProviderInstanceRegistry