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

main
ts 737 lines 27.9 KB
Raw
1 import {
2 providerInstanceConfigEnabledFlag,
3 ProviderInstanceId,
4 type ProviderInstanceConfig,
5 type ProviderInstanceConfigMap,
6 type ProviderInstanceEnvironment,
7 type ProviderDriverKind,
8 type ResolvedProviderInstanceEnvironment,
9 type SecretReference,
10 secretReferencesInSettings,
11 type ServerProvider,
12 type SettingsSecretSlot,
13 withSettingsSecrets,
14 } from "@t3tools/contracts";
15 import * as Context from "effect/Context";
16 import * as Effect from "effect/Effect";
17 import * as Equal from "effect/Equal";
18 import * as Exit from "effect/Exit";
19 import * as Layer from "effect/Layer";
20 import * as Option from "effect/Option";
21 import * as PubSub from "effect/PubSub";
22 import * as Ref from "effect/Ref";
23 import * as Schema from "effect/Schema";
24 import * as Scope from "effect/Scope";
25 import * as Semaphore from "effect/Semaphore";
26 import * as Stream from "effect/Stream";
27
28 import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver";
29
30 import { buildUnavailableProviderSnapshot } from "./unavailableProviderSnapshot.ts";
31 import * as ProviderInstanceRegistryMutator from "./ProviderInstanceRegistryMutator.ts";
32 import type { AnyProviderDriver, ProviderInstance } from "@t3tools/provider-core/server/driver";
33
34 export class ProviderInstanceRegistry extends Context.Service<
35 ProviderInstanceRegistry,
36 {
37 readonly getInstance: (
38 instanceId: ProviderInstanceId,
39 ) => Effect.Effect<ProviderInstance | undefined>;
40 readonly listInstances: Effect.Effect<ReadonlyArray<ProviderInstance>>;
41 readonly listUnavailable: Effect.Effect<ReadonlyArray<ServerProvider>>;
42 /** streamChanges subscribes on consumption; use subscribeChanges before forking to avoid missing the next publish. */
43 readonly streamChanges: Stream.Stream<void>;
44 readonly subscribeChanges: Effect.Effect<PubSub.Subscription<void>, never, Scope.Scope>;
45 }
46 >()("t3/provider/ProviderInstanceRegistry") {}
47
48 interface InstanceSecrets {
49 readonly environment: ResolvedProviderInstanceEnvironment;
50 readonly config: ReadonlyArray<SettingsSecretSlot & { readonly value: string }>;
51 }
52
53 interface LiveEntry {
54 readonly instance: ProviderInstance;
55 readonly scope: Scope.Closeable;
56 readonly entry: ProviderInstanceConfig;
57 readonly secrets: InstanceSecrets;
58 }
59
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
69 const entryEqual = (a: ProviderInstanceConfig, b: ProviderInstanceConfig): boolean =>
70 Equal.equals(a, b);
71
72 const secretReferencesIn = (environment: ProviderInstanceEnvironment): Array<SecretReference> =>
73 environment.flatMap((variable) => (typeof variable.value === "string" ? [] : [variable.value]));
74
75 const configSecretReferences = <R>(
76 driver: AnyProviderDriver<R> | undefined,
77 entry: ProviderInstanceConfig,
78 ) => (driver === undefined ? [] : secretReferencesInSettings(driver.configSchema, entry.config));
79
80 const secretReferencesOf = <R>(
81 driversById: ReadonlyMap<ProviderDriverKind, AnyProviderDriver<R>>,
82 entry: ProviderInstanceConfig,
83 ): ReadonlyArray<SecretReference> => [
84 ...secretReferencesIn(entry.environment ?? []),
85 ...configSecretReferences(driversById.get(entry.driver), entry).map(({ reference }) => reference),
86 ];
87
88 const withoutSecretReferences = (
89 environment: ProviderInstanceEnvironment,
90 ): ResolvedProviderInstanceEnvironment =>
91 environment.flatMap((variable) =>
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);
112 const references = [
113 ...secretReferencesIn(variables),
114 ...configFields.map(({ reference }) => reference),
115 ];
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.
128 const next = () => {
129 const secret = values[index++];
130 return secret === undefined || secret.trim() === "" ? undefined : secret;
131 };
132 const environment: ResolvedProviderInstanceEnvironment = variables.flatMap((variable) => {
133 if (typeof variable.value === "string") return [{ ...variable, value: variable.value }];
134 const secret = next();
135 if (secret === undefined) {
136 unreadable.push(variable.name);
137 return [];
138 }
139 return [{ ...variable, value: secret, sensitive: true }];
140 });
141 const config = configFields.flatMap(({ field, key }) => {
142 const secret = next();
143 if (secret !== undefined) return [{ field, key, value: secret }];
144 unreadable.push(field);
145 return [];
146 });
147 const secrets: InstanceSecrets = { environment, config };
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);
184 if (entry.enabled === false || rawConfigEnabled === false) {
185 return false;
186 }
187 return entry.enabled ?? providerInstanceConfigEnabledFlag(typedConfig) ?? true;
188 };
189
190 type BlockedReason = (driver: ProviderDriverKind) => string | undefined;
191
192 // The enabled state `buildEntry` decodes, so a disabled instance never reads its secrets.
193 const isEntryEnabled = Effect.fn("ProviderInstanceRegistry.isEntryEnabled")(function* <R>(
194 driversById: ReadonlyMap<ProviderDriverKind, AnyProviderDriver<R>>,
195 entry: ProviderInstanceConfig,
196 ) {
197 const driver = driversById.get(entry.driver);
198 if (!driver) return false;
199 const decoder = Schema.decodeUnknownEffect(driver.configSchema);
200 const decoded = yield* decoder(entry.config ?? driver.defaultConfig()).pipe(Effect.option);
201 return Option.isSome(decoded) && resolveEntryEnabled(entry, decoded.value);
202 });
203
204 const buildEntry = Effect.fn("ProviderInstanceRegistry.buildEntry")(function* <R>(input: {
205 readonly driversById: ReadonlyMap<ProviderDriverKind, AnyProviderDriver<R>>;
206 readonly blockedReason: BlockedReason;
207 readonly parentScope: Scope.Scope;
208 readonly instanceId: ProviderInstanceId;
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 | {
216 readonly kind: "unavailable";
217 readonly snapshot: ServerProvider;
218 readonly secretsUnreadable?: true;
219 },
220 never,
221 R | SecretResolver.SecretResolver
222 > {
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 kind: "unavailable" as const,
236 snapshot: yield* buildUnavailableProviderSnapshot({
237 driverKind: entry.driver,
238 instanceId,
239 displayName: entry.displayName,
240 accentColor: entry.accentColor,
241 reason: blocked,
242 }),
243 };
244 }
245 const driver = driversById.get(entry.driver);
246 if (!driver) {
247 return {
248 kind: "unavailable" as const,
249 snapshot: yield* buildUnavailableProviderSnapshot({
250 driverKind: entry.driver,
251 instanceId,
252 displayName: entry.displayName,
253 accentColor: entry.accentColor,
254 reason: `Driver '${entry.driver}' is not registered in this build.`,
255 }),
256 };
257 }
258
259 const decoder = Schema.decodeUnknownEffect(driver.configSchema);
260 const decodeResult = yield* decoder(entry.config ?? driver.defaultConfig()).pipe(Effect.result);
261 if (decodeResult._tag === "Failure") {
262 const issue = decodeResult.failure;
263 const detail = issue.message ?? String(issue);
264 yield* Effect.logError("Failed to decode provider instance config", {
265 instanceId: rawInstanceId,
266 driver: entry.driver,
267 detail,
268 });
269 return {
270 kind: "unavailable" as const,
271 snapshot: yield* buildUnavailableProviderSnapshot({
272 driverKind: entry.driver,
273 instanceId,
274 displayName: entry.displayName,
275 accentColor: entry.accentColor,
276 reason: `Invalid config for instance '${rawInstanceId}': ${detail}`,
277 }),
278 };
279 }
280
281 const typedConfig = decodeResult.success;
282 const enabled = resolveEntryEnabled(entry, typedConfig);
283 if (deferSecrets && enabled && secretReferencesOf(driversById, entry).length > 0) {
284 return {
285 kind: "unavailable" as const,
286 snapshot: yield* buildUnavailableProviderSnapshot({
287 driverKind: entry.driver,
288 instanceId,
289 displayName: entry.displayName,
290 accentColor: entry.accentColor,
291 reason: "Reading secrets…",
292 }),
293 };
294 }
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) {
306 return {
307 kind: "unavailable" as const,
308 secretsUnreadable: true as const,
309 snapshot: yield* buildUnavailableProviderSnapshot({
310 driverKind: entry.driver,
311 instanceId,
312 displayName: entry.displayName,
313 accentColor: entry.accentColor,
314 reason: `Could not read ${unreadable.join(", ")} from its secret provider. Unlock it, then refresh.`,
315 }),
316 };
317 }
318
319 const childScope = yield* Scope.fork(parentScope);
320
321 const createResult = yield* driver
322 .create({
323 instanceId,
324 displayName: entry.displayName,
325 accentColor: entry.accentColor,
326 environment: secrets.environment,
327 enabled,
328 config:
329 secrets.config.length === 0
330 ? typedConfig
331 : withSettingsSecrets(typedConfig, secrets.config),
332 })
333 .pipe(Effect.provideService(Scope.Scope, childScope), Effect.result);
334 if (createResult._tag === "Failure") {
335 yield* Effect.logError("Failed to create provider instance", {
336 instanceId: rawInstanceId,
337 driver: entry.driver,
338 detail: createResult.failure.detail,
339 });
340 yield* Scope.close(childScope, Exit.void).pipe(Effect.ignore);
341 return {
342 kind: "unavailable" as const,
343 snapshot: yield* buildUnavailableProviderSnapshot({
344 driverKind: entry.driver,
345 instanceId,
346 displayName: entry.displayName,
347 accentColor: entry.accentColor,
348 reason: `Driver '${entry.driver}' failed to create instance: ${createResult.failure.detail}`,
349 }),
350 };
351 }
352
353 return {
354 kind: "live" as const,
355 live: {
356 instance: createResult.success,
357 scope: childScope,
358 entry,
359 secrets,
360 },
361 };
362 });
363
364 const makeReconcile = <R>(input: {
365 readonly state: RegistryState;
366 readonly driversById: ReadonlyMap<ProviderDriverKind, AnyProviderDriver<R>>;
367 readonly blockedReason: BlockedReason;
368 readonly parentScope: Scope.Scope;
369 }): ((
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;
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);
380 const previousSecretsUnreadable = yield* Ref.get(state.secretsUnreadable);
381 const nextRaw = Object.entries(configMap);
382 const nextKeys = new Set<ProviderInstanceId>(
383 nextRaw.map(([raw]) => ProviderInstanceId.make(raw)),
384 );
385
386 // Close changed/removed scopes before replacements to preserve one live scope per id.
387 const removedIds: Array<ProviderInstanceId> = [];
388 const replacedIds = new Set<ProviderInstanceId>();
389 for (const [instanceId, live] of previousEntries) {
390 if (!nextKeys.has(instanceId)) {
391 removedIds.push(instanceId);
392 continue;
393 }
394 const nextEntry = configMap[instanceId];
395 if (
396 rebuild.has(instanceId) ||
397 (nextEntry !== undefined && !entryEqual(live.entry, nextEntry))
398 ) {
399 replacedIds.add(instanceId);
400 }
401 }
402 const retiredIds = [...removedIds, ...replacedIds];
403 if (retiredIds.length > 0) {
404 const remaining = new Map(previousEntries);
405 for (const id of retiredIds) remaining.delete(id);
406 yield* Ref.set(state.entries, remaining);
407 }
408 for (const id of retiredIds) {
409 const live = previousEntries.get(id);
410 if (live) {
411 yield* Scope.close(live.scope, Exit.void).pipe(Effect.ignore);
412 }
413 }
414
415 const parkedSnapshot = (instanceId: ProviderInstanceId, entry: ProviderInstanceConfig) => {
416 const parked = previousSecretsUnreadable.get(instanceId);
417 return !rebuild.has(instanceId) && parked !== undefined && entryEqual(parked, entry)
418 ? previousUnavailable.get(instanceId)
419 : undefined;
420 };
421
422 // Read every secret the builds below need in one go, so a vault unlocks once.
423 const references = yield* Effect.forEach(nextRaw, ([rawInstanceId, entry]) =>
424 Effect.gen(function* () {
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 ? []
432 : secretReferencesOf(driversById, entry);
433 }),
434 ).pipe(Effect.map((perEntry) => perEntry.flat()));
435 if (references.length > 0 && !deferSecrets) {
436 yield* (yield* SecretResolver.SecretResolver).read(references);
437 }
438
439 const builtEntries = new Map<ProviderInstanceId, LiveEntry>();
440 const builtUnavailable = new Map<ProviderInstanceId, ServerProvider>();
441 const builtSecretsUnreadable = new Map<ProviderInstanceId, ProviderInstanceConfig>();
442 let orderChanged = false;
443 const previousOrder = [...previousEntries.keys()];
444 const nextOrder: Array<ProviderInstanceId> = [];
445
446 for (const [rawInstanceId, entry] of nextRaw) {
447 const instanceId = ProviderInstanceId.make(rawInstanceId);
448 nextOrder.push(instanceId);
449
450 const existing = previousEntries.get(instanceId);
451 if (existing !== undefined && !replacedIds.has(instanceId)) {
452 builtEntries.set(instanceId, existing);
453 continue;
454 }
455 const parked = parkedSnapshot(instanceId, entry);
456 if (parked !== undefined) {
457 builtUnavailable.set(instanceId, parked);
458 builtSecretsUnreadable.set(instanceId, entry);
459 continue;
460 }
461
462 const result = yield* buildEntry({
463 driversById,
464 blockedReason,
465 parentScope,
466 instanceId,
467 rawInstanceId,
468 entry,
469 deferSecrets,
470 carriedSecrets: carried.get(instanceId),
471 });
472 if (result.kind === "live") {
473 builtEntries.set(instanceId, result.live);
474 } else {
475 builtUnavailable.set(instanceId, result.snapshot);
476 if (result.secretsUnreadable) builtSecretsUnreadable.set(instanceId, entry);
477 }
478 }
479
480 if (previousOrder.length === nextOrder.length) {
481 for (let i = 0; i < previousOrder.length; i++) {
482 if (previousOrder[i] !== nextOrder[i]) {
483 orderChanged = true;
484 break;
485 }
486 }
487 } else {
488 orderChanged = true;
489 }
490
491 const entriesChanged =
492 orderChanged ||
493 removedIds.length > 0 ||
494 replacedIds.size > 0 ||
495 builtEntries.size !== previousEntries.size;
496 const unavailableChanged =
497 builtUnavailable.size !== previousUnavailable.size ||
498 [...builtUnavailable].some(([id, snapshot]) => {
499 const prev = previousUnavailable.get(id);
500 return prev === undefined || !Equal.equals(prev, snapshot);
501 }) ||
502 [...previousUnavailable].some(([id]) => !builtUnavailable.has(id));
503
504 yield* Ref.set(state.entries, builtEntries);
505 yield* Ref.set(state.unavailable, builtUnavailable);
506 yield* Ref.set(state.secretsUnreadable, builtSecretsUnreadable);
507
508 if (entriesChanged || unavailableChanged) {
509 yield* PubSub.publish(state.changes, undefined);
510 }
511 });
512 };
513
514 export const makeProviderInstanceRegistry = Effect.fn(
515 "ProviderInstanceRegistry.makeProviderInstanceRegistry",
516 )(function* <R>(input: {
517 readonly drivers: ReadonlyArray<AnyProviderDriver<R>>;
518 readonly configMap: ProviderInstanceConfigMap;
519 /** A reason to show instead of running a driver, such as an administrator's policy. */
520 readonly blockedReason?: BlockedReason | undefined;
521 }): Effect.fn.Return<
522 {
523 readonly registry: ProviderInstanceRegistry["Service"];
524 readonly mutator: ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutatorShape;
525 },
526 never,
527 R | SecretResolver.SecretResolver | Scope.Scope
528 > {
529 const driversById = new Map<ProviderDriverKind, AnyProviderDriver<R>>(
530 input.drivers.map((driver) => [driver.driverKind, driver]),
531 );
532
533 // Capture the enclosing scope so per-instance child scopes can be
534 // attached to it at `reconcile` time. Without this, `reconcile`
535 // called later (e.g. from the hydration layer) would attach child
536 // scopes to the *caller's* scope instead of the registry's.
537 const parentScope = yield* Scope.Scope;
538
539 const driverContext = yield* Effect.context<R | SecretResolver.SecretResolver>();
540
541 const entries = yield* Ref.make<ReadonlyMap<ProviderInstanceId, LiveEntry>>(new Map());
542 const unavailable = yield* Ref.make<ReadonlyMap<ProviderInstanceId, ServerProvider>>(new Map());
543 const secretsUnreadable = yield* Ref.make<
544 ReadonlyMap<ProviderInstanceId, ProviderInstanceConfig>
545 >(new Map());
546 const changes = yield* PubSub.unbounded<void>();
547 yield* Effect.addFinalizer(() => PubSub.shutdown(changes));
548
549 const state: RegistryState = { entries, unavailable, secretsUnreadable, changes };
550 const reconcileWithR = makeReconcile({
551 state,
552 driversById,
553 blockedReason: input.blockedReason ?? (() => undefined),
554 parentScope,
555 });
556 const configMapRef = yield* Ref.make(input.configMap);
557 const semaphore = yield* Semaphore.make(1);
558 const reconcile: ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutatorShape["reconcile"] =
559 (configMap) =>
560 semaphore.withPermits(1)(
561 Ref.set(configMapRef, configMap).pipe(
562 Effect.andThen(reconcileWithR(configMap)),
563 Effect.provideContext(driverContext),
564 ),
565 );
566
567 // Rebuilds an instance only when it was unavailable or its secrets changed, so a refresh does
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);
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 }
604 continue;
605 }
606 if (checked !== undefined) {
607 const secrets = carryCheckedSecret(
608 driversById.get(entry.driver),
609 current.entry,
610 current.secrets,
611 checked,
612 );
613 if (!Equal.equals(secrets, current.secrets)) {
614 rebuild.add(current.instance.instanceId);
615 carried.set(current.instance.instanceId, secrets);
616 }
617 continue;
618 }
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 rebuild: ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutatorShape["rebuild"] = (
641 instanceIds,
642 ) =>
643 semaphore.withPermits(1)(
644 Ref.get(configMapRef).pipe(
645 Effect.flatMap((configMap) => reconcileWithR(configMap, new Set(instanceIds))),
646 Effect.provideContext(driverContext),
647 ),
648 );
649 const applySecret: ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutatorShape["applySecret"] =
650 (reference, value) =>
651 reloadWhere(
652 (_, entry) =>
653 secretReferencesOf(driversById, entry).some((candidate) =>
654 sameReference(candidate, reference),
655 ),
656 { reference, value },
657 );
658
659 // Reading secrets can wait on a vault unlock, so the server does not wait for it to start.
660 yield* semaphore.withPermits(1)(
661 Ref.set(configMapRef, input.configMap).pipe(
662 Effect.andThen(reconcileWithR(input.configMap, new Set(), true)),
663 Effect.provideContext(driverContext),
664 ),
665 );
666 const startupReferences = yield* Effect.filter(Object.entries(input.configMap), ([, entry]) =>
667 secretReferencesOf(driversById, entry).length > 0
668 ? isEntryEnabled(driversById, entry)
669 : Effect.succeed(false),
670 ).pipe(
671 Effect.map((targets) => targets.flatMap(([, entry]) => secretReferencesOf(driversById, entry))),
672 );
673 if (startupReferences.length > 0) {
674 // The read waits outside the lock so other mutations are not held for a vault prompt; a
675 // configuration saved meanwhile has already reconciled itself.
676 yield* Effect.gen(function* () {
677 yield* (yield* SecretResolver.SecretResolver).read(startupReferences);
678 yield* semaphore.withPermits(1)(
679 Effect.gen(function* () {
680 const current = yield* Ref.get(configMapRef);
681 if (current === input.configMap) yield* reconcileWithR(current);
682 }),
683 );
684 }).pipe(Effect.provideContext(driverContext), Effect.forkScoped);
685 }
686
687 const registry: ProviderInstanceRegistry["Service"] = {
688 getInstance: (id) => Ref.get(entries).pipe(Effect.map((map) => map.get(id)?.instance)),
689 listInstances: Ref.get(entries).pipe(
690 Effect.map(
691 (map) =>
692 Array.from(map.values(), (live) => live.instance) as ReadonlyArray<ProviderInstance>,
693 ),
694 ),
695 listUnavailable: Ref.get(unavailable).pipe(
696 Effect.map((map) => Array.from(map.values()) as ReadonlyArray<ServerProvider>),
697 ),
698 get streamChanges() {
699 return Stream.fromPubSub(changes);
700 },
701 get subscribeChanges() {
702 return PubSub.subscribe(changes);
703 },
704 };
705
706 const mutator: ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutatorShape = {
707 reconcile,
708 reloadSecrets,
709 rebuild,
710 applySecret,
711 };
712
713 return { registry, mutator };
714 });
715
716 export const layer = <R>(input: {
717 readonly drivers: ReadonlyArray<AnyProviderDriver<R>>;
718 readonly configMap: ProviderInstanceConfigMap;
719 readonly blockedReason?: BlockedReason | undefined;
720 }): Layer.Layer<
721 ProviderInstanceRegistry | ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator,
722 never,
723 R | SecretResolver.SecretResolver
724 > =>
725 Layer.effectContext(
726 makeProviderInstanceRegistry(input).pipe(
727 Effect.map(({ registry, mutator }) =>
728 Context.make(ProviderInstanceRegistry, registry).pipe(
729 Context.add(ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator, mutator),
730 ),
731 ),
732 ),
733 ) as Layer.Layer<
734 ProviderInstanceRegistry | ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator,
735 never,
736 R | SecretResolver.SecretResolver
737 >;