The best way to control Claude Code, Codex and more from any computer or phone
| 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 | >; |