@devries-cameron20 / t3code Mirror · read-only / commits / edeea8cd67
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 22, 04:30 UTC

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