The best way to control Claude Code, Codex and more from any computer or phone

main
ts 1,351 lines 54.6 KB
Raw
1 import {
2 defaultInstanceIdForDriver,
3 isProviderWorkspaceSnapshotCurrent,
4 isProviderWorkspaceSnapshotPending,
5 ProviderDriverKind,
6 type ProviderInstanceId,
7 type SecretReference,
8 type ServerProvider,
9 type ServerProviderUpdateState,
10 } from "@t3tools/contracts";
11 import * as Cause from "effect/Cause";
12 import * as Context from "effect/Context";
13 import * as DateTime from "effect/DateTime";
14 import * as Duration from "effect/Duration";
15 import * as Deferred from "effect/Deferred";
16 import * as Effect from "effect/Effect";
17 import * as Equal from "effect/Equal";
18 import * as Fiber from "effect/Fiber";
19 import * as FileSystem from "effect/FileSystem";
20 import * as Layer from "effect/Layer";
21 import * as Option from "effect/Option";
22 import * as Path from "effect/Path";
23 import * as PubSub from "effect/PubSub";
24 import * as Queue from "effect/Queue";
25 import * as Ref from "effect/Ref";
26 import * as Scope from "effect/Scope";
27 import * as Stream from "effect/Stream";
28 import * as Semaphore from "effect/Semaphore";
29
30 import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
31 import * as ModelManifest from "./ModelManifest.ts";
32 import { applyProviderCompatibility } from "./providerCompatibility.ts";
33 import * as ServerConfig from "../config.ts";
34 import { refreshWindowsPath } from "../os-jank.ts";
35 import * as ProviderInstanceRegistry from "./ProviderInstanceRegistry.ts";
36 import * as ProviderInstanceRegistryMutator from "./ProviderInstanceRegistryMutator.ts";
37 import {
38 hydrateCachedProvider,
39 isCachedProviderCorrelated,
40 orderProviderSnapshots,
41 readProviderStatusCache,
42 resolveProviderStatusCachePath,
43 writeProviderStatusCache,
44 } from "./providerStatusCache.ts";
45 import type {
46 ProviderInstance,
47 ProviderWorkspaceSnapshot,
48 } from "@t3tools/provider-core/server/driver";
49 import {
50 makeManualOnlyProviderMaintenanceCapabilities,
51 type ProviderMaintenanceCapabilities,
52 latestProviderVersionCacheKeys,
53 } from "@t3tools/provider-core/server/maintenanceResolver";
54 import type { ProviderSnapshotSource } from "./builtInProviderCatalog.ts";
55
56 export type ProviderMaintenanceActionKind = "update";
57
58 export class ProviderRegistry extends Context.Service<
59 ProviderRegistry,
60 {
61 readonly getProviders: Effect.Effect<ReadonlyArray<ServerProvider>>;
62
63 readonly refresh: (
64 provider?: ProviderDriverKind,
65 ) => Effect.Effect<ReadonlyArray<ServerProvider>>;
66
67 /** Unknown instance ids return the cached list without error. */
68 readonly refreshInstance: (
69 instanceId: ProviderInstanceId,
70 ) => Effect.Effect<ReadonlyArray<ServerProvider>>;
71
72 /** Re-reads secret-backed environments first, so a fixed secret applies without a restart. */
73 readonly reloadSecretsAndRefresh: (
74 instanceId?: ProviderInstanceId,
75 ) => Effect.Effect<ReadonlyArray<ServerProvider>>;
76
77 /** Rebuilds and refreshes only the instances that read a secret, with the value the caller just read. */
78 readonly applySecretAndRefresh: (
79 reference: SecretReference,
80 value: string,
81 ) => Effect.Effect<ReadonlyArray<ServerProvider>>;
82
83 /** Only refreshed instances can verify an update; the published list still includes every row. */
84 readonly refreshAfterUpdate: (
85 provider: ProviderDriverKind,
86 selectedInstanceId: ProviderInstanceId,
87 ) => Effect.Effect<ReadonlyArray<ServerProvider>>;
88
89 readonly refreshWorkspaceSnapshot: (input: {
90 readonly instanceId: ProviderInstanceId;
91 readonly cwd: string;
92 /** Directory the driver scans; the snapshot stays keyed by `cwd`. Defaults to `cwd`. */
93 readonly scanCwd?: string;
94 readonly fresh?: boolean;
95 }) => Effect.Effect<ReadonlyArray<ServerProvider>>;
96
97 /**
98 * Drop T3-owned model caches before an explicit model refresh. Pass the
99 * target of the refresh that follows. Background and ordinary refreshes
100 * keep their cache timers and must not call this.
101 */
102 readonly invalidateModelCaches: (input: {
103 readonly instanceId?: ProviderInstanceId | undefined;
104 readonly cwd?: string | undefined;
105 readonly fresh?: boolean | undefined;
106 }) => Effect.Effect<void>;
107
108 /**
109 * For an opened model picker: refetch a model manifest older than a few
110 * minutes. When it changed, recheck latest CLI versions and probe providers.
111 */
112 readonly refreshModelCatalog: Effect.Effect<void>;
113
114 readonly getProviderMaintenanceCapabilitiesForInstance: (
115 instanceId: ProviderInstanceId,
116 provider: ProviderDriverKind,
117 options?: { readonly fresh?: boolean },
118 ) => Effect.Effect<ProviderMaintenanceCapabilities>;
119
120 readonly setProviderMaintenanceActionState: (input: {
121 readonly instanceId: ProviderInstanceId;
122 readonly action: ProviderMaintenanceActionKind;
123 readonly state: ServerProviderUpdateState | null;
124 readonly targetVersion?: string | undefined;
125 }) => Effect.Effect<ReadonlyArray<ServerProvider>>;
126
127 readonly streamChanges: Stream.Stream<ReadonlyArray<ServerProvider>>;
128 }
129 >()("t3/provider/ProviderRegistry") {}
130
131 const loadProviders = (
132 providerSources: ReadonlyArray<ProviderSnapshotSource>,
133 ): Effect.Effect<ReadonlyArray<ServerProvider>> =>
134 Effect.forEach(
135 providerSources,
136 (providerSource) =>
137 providerSource.getSnapshot.pipe(
138 Effect.flatMap((snapshot) => correlateSnapshotWithSource(providerSource, snapshot)),
139 ),
140 {
141 concurrency: "unbounded",
142 },
143 );
144
145 const makeManualProviderMaintenanceCapabilities = (provider: ProviderDriverKind) =>
146 makeManualOnlyProviderMaintenanceCapabilities({
147 provider,
148 packageName: null,
149 });
150
151 const hasModelCapabilities = (model: ServerProvider["models"][number]): boolean =>
152 (model.capabilities?.optionDescriptors?.length ?? 0) > 0;
153
154 const MAX_WORKSPACE_SNAPSHOTS_PER_PROVIDER = 16;
155
156 function dropProviderWorkspaceSnapshot(provider: ServerProvider, cwd: string): ServerProvider {
157 return provider.workspaceSnapshots?.some((snapshot) => snapshot.cwd === cwd)
158 ? {
159 ...provider,
160 workspaceSnapshots: provider.workspaceSnapshots.filter((snapshot) => snapshot.cwd !== cwd),
161 }
162 : provider;
163 }
164
165 export function upsertProviderWorkspaceSnapshot(
166 provider: ServerProvider,
167 cwd: string,
168 scopedSnapshot: ProviderWorkspaceSnapshot,
169 ): ServerProvider {
170 const previousSnapshot = provider.workspaceSnapshots?.find((snapshot) => snapshot.cwd === cwd);
171 const optionDescriptors = scopedSnapshot.optionDescriptors ?? previousSnapshot?.optionDescriptors;
172 const models = scopedSnapshot.workspaceModelsPending
173 ? previousSnapshot?.models
174 : scopedSnapshot.workspaceModels;
175 const workspaceSnapshot = {
176 cwd,
177 checkedAt: scopedSnapshot.checkedAt,
178 slashCommands: scopedSnapshot.slashCommandsPending
179 ? (previousSnapshot?.slashCommands ?? scopedSnapshot.slashCommands)
180 : scopedSnapshot.slashCommands,
181 ...(scopedSnapshot.slashCommandsPending ? { slashCommandsPending: true } : {}),
182 skills: scopedSnapshot.skills,
183 ...(optionDescriptors === undefined ? {} : { optionDescriptors }),
184 ...(models === undefined ? {} : { models }),
185 ...(scopedSnapshot.workspaceModelsPending ? { modelsPending: true } : {}),
186 } satisfies NonNullable<ServerProvider["workspaceSnapshots"]>[number];
187 return {
188 ...provider,
189 workspaceSnapshots: [
190 ...(provider.workspaceSnapshots ?? []).filter((snapshot) => snapshot.cwd !== cwd),
191 workspaceSnapshot,
192 ].slice(-MAX_WORKSPACE_SNAPSHOTS_PER_PROVIDER),
193 };
194 }
195
196 const shouldRetainMissingProviderModels = (provider: ServerProvider): boolean => {
197 if (provider.driver === ProviderDriverKind.make("pi")) {
198 // Pi auth becomes known only after inventory discovery: empty means unauthenticated; failed/interactive discovery preserves unknown auth and cached models.
199 return !(
200 provider.installed &&
201 (provider.status === "ready" || provider.status === "warning") &&
202 provider.auth.status !== "unknown"
203 );
204 }
205
206 if (provider.driver === ProviderDriverKind.make("acpRegistry")) {
207 // Only completed ACP discovery provides nativeSessions and inventory; placeholder probes cannot establish auth for agents without sign-in.
208 return !(
209 provider.installed &&
210 provider.status === "ready" &&
211 provider.nativeSessions !== undefined
212 );
213 }
214
215 if (provider.driver === ProviderDriverKind.make("kiro")) {
216 // Kiro is ready once `whoami` confirms the account, even when `--list-models` failed and
217 // the snapshot fell back to the built-in list.
218 return true;
219 }
220
221 if (provider.driver === ProviderDriverKind.make("claudeAgent")) {
222 // Claude Code keeps one gateway model cache per Claude home, for one base URL at a time, so a
223 // ready probe can omit this instance's gateway models after another instance or a terminal
224 // `claude` on a different gateway rewrote that cache.
225 return true;
226 }
227
228 const isAntigravity = provider.driver === ProviderDriverKind.make("antigravity");
229 const isCodex = provider.driver === ProviderDriverKind.make("codex");
230 const isOpenCode = provider.driver === ProviderDriverKind.make("opencode");
231 if (!isAntigravity && !isCodex && !isOpenCode) {
232 // Any other driver must report ready only after a completed model listing, or opt out above:
233 // a ready list is authoritative, and warning/error probes keep the old models.
234 return !(provider.installed && provider.status === "ready");
235 }
236
237 if (
238 (isAntigravity || isCodex) &&
239 (!provider.enabled || provider.auth.status === "unauthenticated")
240 ) {
241 return false;
242 }
243
244 // Antigravity's local health check does not authenticate or discover models.
245 const isPendingAntigravityAuthentication =
246 isAntigravity && provider.status === "warning" && provider.auth.status === "unknown";
247 const isPendingInitialProbe =
248 provider.enabled && !provider.installed && provider.status === "warning";
249 // A cold OpenCode server can finish its probe as a warning before it lists any models.
250 const isIncompleteInstalledProbe =
251 provider.installed &&
252 (provider.status === "error" || ((isCodex || isOpenCode) && provider.status === "warning"));
253 return isPendingAntigravityAuthentication || isPendingInitialProbe || isIncompleteInstalledProbe;
254 };
255
256 const shouldRetainMissingOpenCodeMetadata = (provider: ServerProvider): boolean =>
257 provider.driver === ProviderDriverKind.make("opencode") &&
258 shouldRetainMissingProviderModels(provider);
259
260 const mergeProviderModels = (
261 provider: ServerProvider,
262 previousModels: ReadonlyArray<ServerProvider["models"][number]>,
263 nextModels: ReadonlyArray<ServerProvider["models"][number]>,
264 ): ReadonlyArray<ServerProvider["models"][number]> => {
265 const shouldRetainMissingModels = shouldRetainMissingProviderModels(provider);
266 const updateRequiredSlugs = new Set(provider.updateRequiredModels?.map((model) => model.slug));
267 const unavailableSubProviders = new Set(
268 provider.subProviders?.flatMap((subProvider) =>
269 subProvider.unavailableReason === undefined ? [] : [subProvider.name],
270 ),
271 );
272 const retainablePreviousModels = previousModels.filter(
273 (model) =>
274 !model.isCustom &&
275 !updateRequiredSlugs.has(model.slug) &&
276 !unavailableSubProviders.has(model.subProvider ?? ""),
277 );
278
279 if (shouldRetainMissingModels && nextModels.length === 0 && retainablePreviousModels.length > 0) {
280 return retainablePreviousModels;
281 }
282
283 const previousBySlug = new Map(previousModels.map((model) => [model.slug, model] as const));
284 const mergedModels = nextModels.map((model) => {
285 const previousModel = previousBySlug.get(model.slug);
286 if (!previousModel || hasModelCapabilities(model) || !hasModelCapabilities(previousModel)) {
287 return model;
288 }
289 return {
290 ...model,
291 capabilities: previousModel.capabilities,
292 };
293 });
294 const nextSlugs = new Set(nextModels.map((model) => model.slug));
295 return shouldRetainMissingModels
296 ? [...mergedModels, ...retainablePreviousModels.filter((model) => !nextSlugs.has(model.slug))]
297 : mergedModels;
298 };
299
300 /** Antigravity health checks only initialize; preserve previously verified Google auth across restarts. */
301 const carrySavedAntigravityAccount = (
302 previousProvider: ServerProvider,
303 nextProvider: ServerProvider,
304 ): Pick<ServerProvider, "auth" | "status"> | undefined => {
305 const antigravity = ProviderDriverKind.make("antigravity");
306 if (
307 nextProvider.driver !== antigravity ||
308 previousProvider.driver !== antigravity ||
309 !nextProvider.enabled ||
310 nextProvider.auth.status !== "unknown" ||
311 previousProvider.auth.status !== "authenticated" ||
312 (nextProvider.auth.type !== undefined &&
313 nextProvider.auth.type !== previousProvider.auth.type) ||
314 (!nextProvider.installed && nextProvider.status !== "warning")
315 ) {
316 return undefined;
317 }
318 const status =
319 nextProvider.installed && nextProvider.status === "warning" ? "ready" : nextProvider.status;
320 return { auth: previousProvider.auth, status };
321 };
322
323 /** One failed check after a ready one is often transient, so its retained catalog stays offered. */
324 const retainsReadyCatalog = (
325 previousProvider: ServerProvider,
326 nextProvider: ServerProvider,
327 status: ServerProvider["status"],
328 models: ServerProvider["models"],
329 ): boolean =>
330 nextProvider.enabled &&
331 nextProvider.installed &&
332 (status === "error" || status === "warning") &&
333 nextProvider.auth.status !== "unauthenticated" &&
334 models.length > 0 &&
335 (previousProvider.status === "ready" ||
336 // Usage and metadata updates republish the same check.
337 (previousProvider.modelsRetained === true &&
338 previousProvider.checkedAt === nextProvider.checkedAt));
339
340 export const mergeProviderSnapshot = (
341 previousProvider: ServerProvider | undefined,
342 nextProvider: ServerProvider,
343 ): ServerProvider => {
344 if (!previousProvider) {
345 return nextProvider;
346 }
347 const savedAccount = carrySavedAntigravityAccount(previousProvider, nextProvider);
348 const { message: _uncheckedMessage, ...nextWithoutMessage } = nextProvider;
349 const models = mergeProviderModels(nextProvider, previousProvider.models, nextProvider.models);
350 // Folder catalogs were compared with the old machine catalog, so every folder rescans.
351 const previousWorkspaceSnapshots = Equal.equals(models, previousProvider.models)
352 ? previousProvider.workspaceSnapshots
353 : previousProvider.workspaceSnapshots?.map((snapshot) => ({
354 ...snapshot,
355 modelsPending: true,
356 }));
357 const nextWorkspaceSnapshots = nextProvider.workspaceSnapshots;
358 // A provider reports only folders its own sessions saw, so registry scans of other folders stay.
359 const workspaceSnapshots =
360 nextWorkspaceSnapshots === undefined ||
361 !nextProvider.enabled ||
362 nextProvider.auth.status === "unauthenticated" ||
363 (!nextProvider.installed && nextProvider.status === "error")
364 ? (nextWorkspaceSnapshots ?? previousWorkspaceSnapshots)
365 : [
366 ...(previousWorkspaceSnapshots ?? []).filter(
367 ({ cwd }) => !nextWorkspaceSnapshots.some((snapshot) => snapshot.cwd === cwd),
368 ),
369 ...nextWorkspaceSnapshots,
370 ].slice(-MAX_WORKSPACE_SNAPSHOTS_PER_PROVIDER);
371 return {
372 ...(savedAccount?.status === "ready" ? nextWithoutMessage : nextProvider),
373 ...savedAccount,
374 models,
375 ...(retainsReadyCatalog(
376 previousProvider,
377 nextProvider,
378 savedAccount?.status ?? nextProvider.status,
379 models,
380 )
381 ? { modelsRetained: true }
382 : {}),
383 ...(workspaceSnapshots === undefined ? {} : { workspaceSnapshots }),
384 ...(nextProvider.workspaceRescannedAt === undefined &&
385 previousProvider.workspaceRescannedAt !== undefined
386 ? { workspaceRescannedAt: previousProvider.workspaceRescannedAt }
387 : {}),
388 ...(shouldRetainMissingOpenCodeMetadata(nextProvider)
389 ? {
390 slashCommands:
391 nextProvider.slashCommands.length === 0
392 ? previousProvider.slashCommands
393 : nextProvider.slashCommands,
394 skills: nextProvider.skills.length === 0 ? previousProvider.skills : nextProvider.skills,
395 }
396 : {}),
397 };
398 };
399
400 const haveProvidersChanged = (
401 previousProviders: ReadonlyArray<ServerProvider>,
402 nextProviders: ReadonlyArray<ServerProvider>,
403 ): boolean => !Equal.equals(previousProviders, nextProviders);
404
405 const correlateSnapshotWithSource = (
406 source: ProviderSnapshotSource,
407 snapshot: ServerProvider,
408 ): Effect.Effect<ServerProvider> => {
409 if (snapshot.instanceId !== source.instanceId) {
410 return Effect.die(
411 new Error(
412 `Provider snapshot instance mismatch: source '${source.instanceId}' emitted '${snapshot.instanceId}'.`,
413 ),
414 );
415 }
416 if (snapshot.driver !== source.driverKind) {
417 return Effect.die(
418 new Error(
419 `Provider snapshot driver mismatch for instance '${source.instanceId}': source '${source.driverKind}' emitted '${snapshot.driver}'.`,
420 ),
421 );
422 }
423 return Effect.succeed(snapshot);
424 };
425
426 const snapshotInstanceKey = (provider: ServerProvider): ProviderInstanceId => {
427 return provider.instanceId;
428 };
429
430 // Rebuilt instances have new PubSubs; capture their fresh closures instead of a closed source.
431 const buildSnapshotSource = (instance: ProviderInstance): ProviderSnapshotSource => ({
432 instanceId: instance.instanceId,
433 driverKind: instance.driverKind,
434 getSnapshot: instance.snapshot.getSnapshot,
435 refresh: instance.snapshot.refresh,
436 streamChanges: instance.snapshot.streamChanges,
437 });
438
439 export const layer = Layer.effect(
440 ProviderRegistry,
441 Effect.gen(function* () {
442 const instanceRegistry = yield* ProviderInstanceRegistry.ProviderInstanceRegistry;
443 const instanceRegistryMutator =
444 yield* ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator;
445 const manifestService = yield* ModelManifest.ModelManifest;
446 const latestVersions = yield* ProviderLatestVersions.ProviderLatestVersions;
447 const serviceScope = yield* Effect.scope;
448 const config = yield* ServerConfig.ServerConfig;
449 const fileSystem = yield* FileSystem.FileSystem;
450 const path = yield* Path.Path;
451
452 const changesPubSub = yield* Effect.acquireRelease(
453 PubSub.unbounded<ReadonlyArray<ServerProvider>>(),
454 PubSub.shutdown,
455 );
456
457 const bootInstances = yield* instanceRegistry.listInstances;
458 const bootSources = bootInstances.map(buildSnapshotSource);
459 const fallbackProviders = yield* loadProviders(bootSources);
460 const fallbackByInstance = new Map<ProviderInstanceId, ServerProvider>();
461 for (let index = 0; index < fallbackProviders.length; index++) {
462 const provider = fallbackProviders[index];
463 const source = bootSources[index];
464 if (provider === undefined || source === undefined) {
465 continue;
466 }
467 fallbackByInstance.set(source.instanceId, provider);
468 }
469 // Read after the snapshots: a snapshot read as awaiting is the pre-check placeholder.
470 const awaitingBootInstances = new Set<ProviderInstance>();
471 for (const instance of bootInstances) {
472 if (yield* instance.snapshot.isAwaitingFirstCheck ?? Effect.succeed(false)) {
473 awaitingBootInstances.add(instance);
474 }
475 }
476
477 const bootProviders = yield* Effect.forEach(
478 bootSources,
479 (source, index) =>
480 Effect.gen(function* () {
481 const filePath = yield* resolveProviderStatusCachePath({
482 cacheDir: config.providerStatusCacheDir,
483 instanceId: source.instanceId,
484 }).pipe(Effect.provideService(Path.Path, path));
485 const fallbackProvider = fallbackByInstance.get(source.instanceId);
486 if (fallbackProvider === undefined) {
487 return undefined;
488 }
489 // A completed check is seeded by the boot upsert instead, which persists it.
490 const placeholder = awaitingBootInstances.has(bootInstances[index]!)
491 ? fallbackProvider
492 : undefined;
493 return yield* readProviderStatusCache(filePath).pipe(
494 Effect.provideService(FileSystem.FileSystem, fileSystem),
495 Effect.flatMap((cachedProvider) => {
496 if (cachedProvider === undefined) {
497 return Effect.succeed(placeholder);
498 }
499 const correlation = {
500 cachedProvider,
501 fallbackProvider,
502 } as const;
503 if (!isCachedProviderCorrelated(correlation)) {
504 return Effect.logWarning("provider status cache identity mismatch, ignoring", {
505 path: filePath,
506 instanceId: source.instanceId,
507 cachedInstanceId: cachedProvider.instanceId ?? null,
508 driver: source.driverKind,
509 cachedDriver: cachedProvider.driver ?? null,
510 }).pipe(Effect.as(placeholder));
511 }
512 return Effect.succeed(hydrateCachedProvider(correlation));
513 }),
514 );
515 }),
516 { concurrency: "unbounded" },
517 ).pipe(
518 Effect.map((providers) =>
519 orderProviderSnapshots(
520 providers.filter((provider): provider is ServerProvider => provider !== undefined),
521 ),
522 ),
523 );
524 const initialManifest = yield* manifestService.current;
525 const classifyCompatibility = (
526 provider: ServerProvider,
527 manifest: ModelManifest.ModelManifestData,
528 ) =>
529 applyProviderCompatibility(
530 provider,
531 manifest.compatibility,
532 ModelManifest.BUNDLED_MODEL_MANIFEST.compatibility,
533 );
534 const providersRef = yield* Ref.make<ReadonlyArray<ServerProvider>>(
535 bootProviders.map((provider) => classifyCompatibility(provider, initialManifest)),
536 );
537 const workspaceRefreshesRef = yield* Ref.make<
538 ReadonlyMap<ProviderInstance, ReadonlyMap<string, Deferred.Deferred<void>>>
539 >(new Map());
540 const workspaceRescans = yield* Queue.unbounded<{
541 readonly instance: ProviderInstance;
542 readonly cwd: string;
543 }>();
544 const maintenanceActionStatesRef = yield* Ref.make<
545 ReadonlyMap<
546 ProviderInstanceId,
547 { readonly update?: ServerProviderUpdateState; readonly targetVersion?: string | undefined }
548 >
549 >(new Map());
550
551 const liveSubsRef = yield* Ref.make<ReadonlyMap<ProviderInstanceId, ProviderInstance>>(
552 new Map(),
553 );
554 const syncSemaphore = yield* Semaphore.make(1);
555
556 const persistProvider = Effect.fn("ProviderRegistry.persistProvider")(function* (
557 provider: ServerProvider,
558 ) {
559 const key = snapshotInstanceKey(provider);
560 const filePath = yield* resolveProviderStatusCachePath({
561 cacheDir: config.providerStatusCacheDir,
562 instanceId: key,
563 }).pipe(Effect.provideService(Path.Path, path));
564 const {
565 workspaceSnapshots: _workspaceSnapshots,
566 workspaceRescannedAt: _workspaceRescannedAt,
567 ...machineProvider
568 } = provider;
569 yield* writeProviderStatusCache({ filePath, provider: machineProvider }).pipe(
570 Effect.provideService(FileSystem.FileSystem, fileSystem),
571 Effect.provideService(Path.Path, path),
572 Effect.tapError(Effect.logError),
573 Effect.ignore,
574 );
575 });
576
577 const applyProviderUpdateState = Effect.fn("applyProviderUpdateState")(function* (
578 provider: ServerProvider,
579 ) {
580 const maintenanceActionStates = yield* Ref.get(maintenanceActionStatesRef);
581 const updateState = maintenanceActionStates.get(provider.instanceId)?.update;
582 if (!updateState) {
583 const { updateState: _updateState, ...providerWithoutUpdateState } = provider;
584 return providerWithoutUpdateState;
585 }
586 return {
587 ...provider,
588 updateState,
589 };
590 });
591
592 const upsertProviders = Effect.fn("upsertProviders")(function* (
593 nextProviders: ReadonlyArray<ServerProvider>,
594 options?: {
595 readonly publish?: boolean;
596 readonly persist?: boolean;
597 readonly replace?: boolean;
598 },
599 ) {
600 const manifest = yield* manifestService.current;
601 const nextProvidersWithUpdateState = yield* Effect.forEach(
602 nextProviders,
603 applyProviderUpdateState,
604 {
605 concurrency: "unbounded",
606 },
607 );
608 const [previousProviders, providers, providersToPersist] = yield* Ref.modify(
609 providersRef,
610 (previousProviders) => {
611 const mergedProviders = new Map(
612 previousProviders.map((provider) => [snapshotInstanceKey(provider), provider] as const),
613 );
614 const updatedKeys = new Set<ProviderInstanceId>();
615
616 for (const provider of nextProvidersWithUpdateState) {
617 const key = snapshotInstanceKey(provider);
618 updatedKeys.add(key);
619 mergedProviders.set(
620 key,
621 options?.replace === true
622 ? provider
623 : mergeProviderSnapshot(mergedProviders.get(key), provider),
624 );
625 }
626
627 const providers = orderProviderSnapshots(
628 [...mergedProviders.values()].map((provider) =>
629 classifyCompatibility(provider, manifest),
630 ),
631 );
632 const providersToPersist = providers.filter((provider) =>
633 updatedKeys.has(snapshotInstanceKey(provider)),
634 );
635 return [[previousProviders, providers, providersToPersist] as const, providers];
636 },
637 );
638
639 if (haveProvidersChanged(previousProviders, providers)) {
640 if (options?.persist !== false) {
641 yield* Effect.forEach(providersToPersist, persistProvider, {
642 concurrency: "unbounded",
643 discard: true,
644 });
645 }
646 if (options?.publish !== false) {
647 // A newer upsert may have committed and published during the cache write; never republish an older array.
648 yield* PubSub.publish(changesPubSub, yield* Ref.get(providersRef));
649 }
650 }
651
652 return providers;
653 });
654
655 const compatibilityRefreshRunning = yield* Ref.make(false);
656 // Reclassify the current model after fetch; republishing the old probe could overwrite newer health results.
657 const refreshCompatibility = Effect.gen(function* () {
658 if (!(yield* Ref.getAndSet(compatibilityRefreshRunning, true))) {
659 yield* manifestService.refresh.pipe(
660 Effect.andThen(upsertProviders([], { persist: false })),
661 Effect.ensuring(Ref.set(compatibilityRefreshRunning, false)),
662 Effect.forkIn(serviceScope),
663 );
664 }
665 });
666 const syncProvider = Effect.fn("syncProvider")(function* (
667 provider: ServerProvider,
668 options?: {
669 readonly publish?: boolean;
670 },
671 ) {
672 // Latest-version status cannot resolve a failed recommended-version install.
673 if (provider.versionAdvisory?.status === "current") {
674 yield* Ref.update(maintenanceActionStatesRef, (previous) => {
675 const action = previous.get(provider.instanceId);
676 if (
677 action?.targetVersion !== undefined ||
678 (action?.update?.status !== "unchanged" && action?.update?.status !== "failed")
679 ) {
680 return previous;
681 }
682 const next = new Map(previous);
683 next.delete(provider.instanceId);
684 return next;
685 });
686 }
687 const providers = yield* upsertProviders([provider], options);
688 yield* refreshCompatibility;
689 return providers;
690 });
691
692 const setProviderMaintenanceActionState = Effect.fn("setProviderMaintenanceActionState")(
693 function* (input: {
694 readonly instanceId: ProviderInstanceId;
695 readonly action: "update";
696 readonly state: ServerProviderUpdateState | null;
697 readonly targetVersion?: string | undefined;
698 }) {
699 yield* Ref.update(maintenanceActionStatesRef, (previous) => {
700 const next = new Map(previous);
701 if (input.state === null || input.state.status === "idle") {
702 next.delete(input.instanceId);
703 } else {
704 next.set(input.instanceId, { update: input.state, targetVersion: input.targetVersion });
705 }
706 return next;
707 });
708
709 const existingProviders = yield* Ref.get(providersRef);
710 const matchingProvider = existingProviders.find(
711 (candidate) => candidate.instanceId === input.instanceId,
712 );
713 if (!matchingProvider) {
714 return existingProviders;
715 }
716
717 const nextProvider = yield* applyProviderUpdateState(matchingProvider);
718 return yield* upsertProviders([nextProvider], {
719 persist: false,
720 });
721 },
722 );
723
724 const isCurrentInstance = (instance: ProviderInstance) =>
725 instanceRegistry
726 .getInstance(instance.instanceId)
727 .pipe(Effect.map((current) => current === instance));
728
729 const refreshOneSource = Effect.fn("refreshOneSource")(function* (instance: ProviderInstance) {
730 const providerSource = buildSnapshotSource(instance);
731 // Enrichment can publish a newer snapshot before refresh returns its pre-enrichment probe.
732 const probe = yield* providerSource.refresh.pipe(
733 Effect.andThen(providerSource.getSnapshot),
734 Effect.exit,
735 );
736 // Settings can replace or remove the instance mid-probe; its late result or failure is stale.
737 if (!(yield* isCurrentInstance(instance))) {
738 return yield* Ref.get(providersRef);
739 }
740 const nextProvider = yield* probe;
741 return yield* correlateSnapshotWithSource(providerSource, nextProvider).pipe(
742 Effect.flatMap(syncProvider),
743 );
744 });
745
746 type RefreshAllCompletion = Deferred.Deferred<ReadonlyArray<ServerProvider>>;
747 // A refresh is how a user asks T3 to see a CLI installed since launch; a burst shares one probe.
748 // Drivers copy the environment when built, so instances still missing their CLI are rebuilt
749 // on the new PATH. They cannot have live sessions, and installed ones keep theirs.
750 const refreshHostPath = yield* refreshWindowsPath().pipe(
751 Effect.flatMap((changed) =>
752 changed
753 ? Ref.get(providersRef).pipe(
754 Effect.flatMap((providers) =>
755 instanceRegistryMutator.rebuild(
756 providers
757 .filter((provider) => provider.enabled && !provider.installed)
758 .map((provider) => provider.instanceId),
759 ),
760 ),
761 )
762 : Effect.void,
763 ),
764 Effect.cachedWithTTL(Duration.seconds(10)),
765 );
766 const refreshAllInFlightRef = yield* Ref.make<Option.Option<RefreshAllCompletion>>(
767 Option.none(),
768 );
769
770 // What the last full pass could see; a later manifest fetch does not reach providers by itself.
771 const probedManifestUpdatedAt = yield* Ref.make(initialManifest.updatedAt);
772
773 const refreshAll = Effect.fn("refreshAll")(function* () {
774 yield* refreshHostPath;
775 const claimed = yield* Ref.modify(
776 refreshAllInFlightRef,
777 (
778 inFlight,
779 ): readonly [
780 { readonly owner: boolean; readonly completion: RefreshAllCompletion },
781 Option.Option<RefreshAllCompletion>,
782 ] => {
783 if (Option.isSome(inFlight)) {
784 return [{ owner: false, completion: inFlight.value }, inFlight];
785 }
786 const completion = Deferred.makeUnsafe<ReadonlyArray<ServerProvider>>();
787 return [{ owner: true, completion }, Option.some(completion)];
788 },
789 );
790 if (claimed.owner) {
791 // Detach shared passes so the first caller's interruption cannot cancel other callers' work.
792 // Syncing first keeps a refresh right after a rebuild from probing the replaced instance.
793 yield* manifestService.current.pipe(
794 Effect.flatMap(({ updatedAt }) =>
795 syncLiveSourcesAndContinue.pipe(
796 Effect.andThen(Ref.get(liveSubsRef)),
797 Effect.flatMap((instances) =>
798 Effect.forEach(instances.values(), (instance) => refreshOneSource(instance), {
799 concurrency: "unbounded",
800 discard: true,
801 }),
802 ),
803 Effect.andThen(Ref.get(providersRef)),
804 Effect.tap(() => Ref.set(probedManifestUpdatedAt, updatedAt)),
805 ),
806 ),
807 Effect.onExit((exit) =>
808 Ref.set(refreshAllInFlightRef, Option.none()).pipe(
809 Effect.andThen(Deferred.done(claimed.completion, exit)),
810 ),
811 ),
812 Effect.forkDetach,
813 );
814 }
815 return yield* Deferred.await(claimed.completion);
816 });
817
818 const refresh = Effect.fn("refresh")(function* (provider?: ProviderDriverKind) {
819 if (provider === undefined) {
820 return yield* refreshAll();
821 }
822 return yield* refreshInstance(defaultInstanceIdForDriver(provider));
823 });
824
825 const refreshInstance = Effect.fn("refreshInstance")(function* (
826 instanceId: ProviderInstanceId,
827 ) {
828 yield* refreshHostPath;
829 yield* syncLiveSourcesAndContinue;
830 const instance = (yield* Ref.get(liveSubsRef)).get(instanceId);
831 if (!instance) {
832 return yield* Ref.get(providersRef);
833 }
834 return yield* refreshOneSource(instance);
835 });
836
837 const reloadSecretsAndRefresh = Effect.fn("reloadSecretsAndRefresh")(function* (
838 instanceId?: ProviderInstanceId,
839 ) {
840 yield* instanceRegistryMutator.reloadSecrets(instanceId);
841 return yield* instanceId === undefined ? refresh() : refreshInstance(instanceId);
842 });
843
844 const applySecretAndRefresh = Effect.fn("applySecretAndRefresh")(function* (
845 reference: SecretReference,
846 value: string,
847 ) {
848 const instanceIds = yield* instanceRegistryMutator.applySecret(reference, value);
849 yield* Effect.forEach(instanceIds, refreshInstance, { discard: true });
850 return yield* Ref.get(providersRef);
851 });
852
853 const refreshAfterUpdate = Effect.fn("refreshAfterUpdate")(function* (
854 provider: ProviderDriverKind,
855 selectedInstanceId: ProviderInstanceId,
856 ) {
857 yield* manifestService.forceRefresh;
858 const instances = (yield* instanceRegistry.listInstances).filter(
859 (instance) =>
860 instance.driverKind === provider &&
861 (instance.enabled || instance.instanceId === selectedInstanceId),
862 );
863 const failedInstances = new Set<ProviderInstanceId>();
864 const recoverInstanceFailure = Effect.fn("recoverPostUpdateRefreshFailure")(function* (
865 instanceId: ProviderInstanceId,
866 cause: Cause.Cause<unknown>,
867 ) {
868 if (Cause.hasInterruptsOnly(cause)) {
869 return yield* Effect.interrupt;
870 }
871 yield* Effect.logError("provider post-update refresh failed", {
872 instanceId,
873 cause: Cause.pretty(cause),
874 });
875 failedInstances.add(instanceId);
876 // A cached ready snapshot cannot verify a successful update.
877 return yield* updateProviders((providers) =>
878 providers.map((candidate) =>
879 candidate.instanceId === instanceId
880 ? { ...candidate, status: "error", message: "Provider refresh failed after update." }
881 : candidate,
882 ),
883 );
884 });
885 // Instances can share the replaced service, so none may invalidate before it restarts.
886 const selectedInstance = instances.find(
887 (instance) => instance.instanceId === selectedInstanceId,
888 );
889 if (selectedInstance?.afterUpdate !== undefined) {
890 // The probe below reports what is running, so a failed hook needs no status of its own.
891 yield* selectedInstance.afterUpdate.pipe(
892 Effect.catchCause((cause) =>
893 Cause.hasInterruptsOnly(cause)
894 ? Effect.interrupt
895 : Effect.logError("provider post-update hook failed", {
896 instanceId: selectedInstance.instanceId,
897 cause: Cause.pretty(cause),
898 }),
899 ),
900 );
901 }
902 // Accounts can share an installation, but discovery must use each
903 // instance's own executable, environment, and credentials.
904 yield* Effect.forEach(
905 instances,
906 (instance) =>
907 Effect.gen(function* () {
908 yield* instance.invalidateCaches ?? Effect.void;
909 const maintenance = yield* instance.snapshot.resolveMaintenance({ fresh: true });
910 yield* Effect.forEach(
911 latestProviderVersionCacheKeys(maintenance),
912 latestVersions.invalidate,
913 { discard: true },
914 );
915 }).pipe(Effect.catchCause((cause) => recoverInstanceFailure(instance.instanceId, cause))),
916 { concurrency: "unbounded", discard: true },
917 );
918 yield* Effect.forEach(
919 instances.filter((instance) => !failedInstances.has(instance.instanceId)),
920 (instance) =>
921 refreshOneSource(instance).pipe(
922 Effect.catchCause((cause) => recoverInstanceFailure(instance.instanceId, cause)),
923 ),
924 { concurrency: "unbounded", discard: true },
925 );
926 // A replaced instance's cached row did not come from this pass's probe.
927 const refreshedInstances = yield* Effect.filter(
928 instances.filter((instance) => !failedInstances.has(instance.instanceId)),
929 isCurrentInstance,
930 );
931 const refreshedInstanceIds = new Set(
932 refreshedInstances.map((instance) => instance.instanceId),
933 );
934 return (yield* Ref.get(providersRef)).filter((candidate) =>
935 refreshedInstanceIds.has(candidate.instanceId),
936 );
937 });
938
939 const getProviderMaintenanceCapabilitiesForInstance = Effect.fn(
940 "getProviderMaintenanceCapabilitiesForInstance",
941 )(function* (
942 instanceId: ProviderInstanceId,
943 provider: ProviderDriverKind,
944 options?: { readonly fresh?: boolean },
945 ) {
946 // liveSubsRef trails reconciliation and could run a retired instance's command; read the registry.
947 const instance = yield* instanceRegistry.getInstance(instanceId);
948 if (!instance || instance.driverKind !== provider) {
949 return makeManualProviderMaintenanceCapabilities(provider);
950 }
951 return yield* instance.snapshot.resolveMaintenance(options);
952 });
953
954 const syncLiveSources = syncSemaphore.withPermits(1)(
955 Effect.gen(function* () {
956 const instances = yield* instanceRegistry.listInstances;
957 const unavailableProviders = yield* instanceRegistry.listUnavailable;
958 const nextByInstance = new Map<ProviderInstanceId, ProviderInstance>(
959 instances.map((instance) => [instance.instanceId, instance] as const),
960 );
961 const knownInstanceIds = new Set<ProviderInstanceId>(nextByInstance.keys());
962 for (const provider of unavailableProviders) {
963 knownInstanceIds.add(snapshotInstanceKey(provider));
964 }
965 const previousSubs = yield* Ref.get(liveSubsRef);
966
967 const carriedOver = new Map<ProviderInstanceId, ProviderInstance>();
968 for (const [instanceId, previousInstance] of previousSubs) {
969 const nextInstance = nextByInstance.get(instanceId);
970 if (nextInstance !== undefined && nextInstance === previousInstance) {
971 carriedOver.set(instanceId, previousInstance);
972 }
973 }
974
975 const newlyAdded: Array<readonly [ProviderInstanceId, ProviderInstance]> = [];
976 for (const [instanceId, instance] of nextByInstance) {
977 if (carriedOver.has(instanceId)) {
978 continue;
979 }
980 newlyAdded.push([instanceId, instance] as const);
981 }
982
983 const rebuiltInstanceIds = new Set(
984 newlyAdded
985 .map(([instanceId]) => instanceId)
986 .filter((instanceId) => previousSubs.has(instanceId)),
987 );
988 if (rebuiltInstanceIds.size > 0) {
989 const [previousProviders, providers] = yield* Ref.modify(
990 providersRef,
991 (previousProviders) => {
992 const providers = previousProviders.map((provider) => {
993 if (!rebuiltInstanceIds.has(provider.instanceId)) return provider;
994 const { workspaceSnapshots: _workspaceSnapshots, ...machineSnapshot } = provider;
995 return machineSnapshot;
996 });
997 return [[previousProviders, providers] as const, providers];
998 },
999 );
1000 if (haveProvidersChanged(previousProviders, providers)) {
1001 yield* PubSub.publish(changesPubSub, providers);
1002 }
1003 }
1004
1005 // Subscribe before reading so a probe completing mid-sync is observed by at least one path.
1006 for (const [, instance] of newlyAdded) {
1007 const source = buildSnapshotSource(instance);
1008 yield* Stream.runForEach(source.streamChanges, (provider) =>
1009 correlateSnapshotWithSource(source, provider).pipe(Effect.flatMap(syncProvider)),
1010 ).pipe(Effect.forkScoped);
1011 if (instance.workspaceRescans) {
1012 yield* Stream.runForEach(instance.workspaceRescans, (cwd) =>
1013 Queue.offer(workspaceRescans, { instance, cwd }),
1014 ).pipe(Effect.forkScoped);
1015 }
1016 }
1017 yield* Effect.yieldNow;
1018
1019 yield* Effect.forEach(
1020 newlyAdded,
1021 ([, instance]) =>
1022 Effect.gen(function* () {
1023 const source = buildSnapshotSource(instance);
1024 const provider = yield* source.getSnapshot;
1025 // Boot shows the cached status until this instance's first check publishes a result.
1026 if (
1027 awaitingBootInstances.has(instance) &&
1028 (yield* instance.snapshot.isAwaitingFirstCheck ?? Effect.succeed(false))
1029 ) {
1030 return yield* refreshCompatibility;
1031 }
1032 yield* correlateSnapshotWithSource(source, provider).pipe(
1033 Effect.flatMap(syncProvider),
1034 );
1035 }).pipe(Effect.ignoreCause({ log: true })),
1036 { concurrency: "unbounded", discard: true },
1037 );
1038 yield* upsertProviders(unavailableProviders, {
1039 persist: false,
1040 replace: true,
1041 });
1042
1043 const nextSubs = new Map(carriedOver);
1044 for (const [instanceId, instance] of newlyAdded) {
1045 nextSubs.set(instanceId, instance);
1046 }
1047 yield* Ref.set(liveSubsRef, nextSubs);
1048
1049 const [previousProviders, providers] = yield* Ref.modify(
1050 providersRef,
1051 (previousProviders) => {
1052 const providers = orderProviderSnapshots(
1053 previousProviders.filter((provider) =>
1054 knownInstanceIds.has(snapshotInstanceKey(provider)),
1055 ),
1056 );
1057 return [[previousProviders, providers] as const, providers];
1058 },
1059 );
1060 if (haveProvidersChanged(previousProviders, providers)) {
1061 yield* PubSub.publish(changesPubSub, providers);
1062 }
1063 yield* Ref.update(maintenanceActionStatesRef, (previous) => {
1064 const next = new Map(previous);
1065 for (const instanceId of previous.keys()) {
1066 if (!knownInstanceIds.has(instanceId)) {
1067 next.delete(instanceId);
1068 }
1069 }
1070 return next;
1071 });
1072 }),
1073 );
1074 const syncLiveSourcesAndContinue = syncLiveSources.pipe(
1075 Effect.catchCause((cause) => {
1076 if (Cause.hasInterruptsOnly(cause)) {
1077 return Effect.interrupt;
1078 }
1079 return Effect.logError(
1080 "provider registry instance sync failed; keeping subscription alive",
1081 {
1082 cause: Cause.pretty(cause),
1083 },
1084 );
1085 }),
1086 Scope.provide(serviceScope),
1087 );
1088
1089 yield* upsertProviders(
1090 fallbackProviders.filter((_, index) => !awaitingBootInstances.has(bootInstances[index]!)),
1091 { publish: false },
1092 );
1093 const instanceChanges = yield* instanceRegistry.subscribeChanges;
1094 yield* syncLiveSources;
1095 yield* Stream.runForEach(
1096 Stream.fromSubscription(instanceChanges),
1097 () => syncLiveSourcesAndContinue,
1098 ).pipe(Effect.forkScoped);
1099
1100 const recoverRefreshFailure = Effect.fn("recoverRefreshFailure")(function* (
1101 cause: Cause.Cause<unknown>,
1102 ) {
1103 if (Cause.hasInterruptsOnly(cause)) {
1104 return yield* Effect.interrupt;
1105 }
1106 yield* Effect.logError("provider registry refresh failed; preserving cached providers", {
1107 cause: Cause.pretty(cause),
1108 });
1109 return yield* Ref.get(providersRef);
1110 });
1111
1112 const updateProviders = (
1113 update: (providers: ReadonlyArray<ServerProvider>) => ReadonlyArray<ServerProvider>,
1114 ) =>
1115 Ref.modify(providersRef, (currentProviders) => {
1116 const nextProviders = update(currentProviders);
1117 return [[currentProviders, nextProviders] as const, nextProviders];
1118 }).pipe(
1119 Effect.tap(([previousProviders, nextProviders]) =>
1120 haveProvidersChanged(previousProviders, nextProviders)
1121 ? PubSub.publish(changesPubSub, nextProviders)
1122 : Effect.void,
1123 ),
1124 Effect.map(([, nextProviders]) => nextProviders),
1125 );
1126
1127 const refreshWorkspaceSnapshot = Effect.fn("refreshWorkspaceSnapshot")(function* (input: {
1128 readonly instanceId: ProviderInstanceId;
1129 readonly cwd: string;
1130 readonly scanCwd?: string;
1131 readonly fresh?: boolean;
1132 // Set by an instance's own report that its workspace skills changed.
1133 readonly rescan?: ProviderInstance;
1134 }) {
1135 const workspaceSnapshotOf = (candidate: ServerProvider | undefined) =>
1136 candidate?.workspaceSnapshots?.find((s) => s.cwd === input.cwd);
1137 // What clients saw before the awaited scan, which may already have published the change.
1138 const heldBeforeWait = input.rescan
1139 ? workspaceSnapshotOf(
1140 (yield* Ref.get(providersRef)).find(
1141 (candidate) => candidate.instanceId === input.instanceId,
1142 ),
1143 )
1144 : undefined;
1145 // A rescan waits for a running scan, which may have read files before the hook linked them.
1146 // Claims are read before snapshots: a scan publishes before it releases its claim.
1147 const runningScan = input.rescan
1148 ? (yield* Ref.get(workspaceRefreshesRef)).get(input.rescan)?.get(input.cwd)
1149 : undefined;
1150 if (runningScan) yield* Deferred.await(runningScan);
1151 if (input.fresh) {
1152 yield* updateProviders((providers) =>
1153 providers.map((candidate) =>
1154 candidate.instanceId === input.instanceId
1155 ? candidate
1156 : dropProviderWorkspaceSnapshot(candidate, input.cwd),
1157 ),
1158 );
1159 }
1160 const providers = yield* Ref.get(providersRef);
1161 const provider = providers.find((candidate) => candidate.instanceId === input.instanceId);
1162 const scannedFrom = workspaceSnapshotOf(provider);
1163 const now = yield* DateTime.now;
1164 if (
1165 !provider ||
1166 !provider.enabled ||
1167 (!input.fresh &&
1168 !input.rescan &&
1169 scannedFrom &&
1170 !isProviderWorkspaceSnapshotPending(scannedFrom) &&
1171 isProviderWorkspaceSnapshotCurrent(scannedFrom, DateTime.toEpochMillis(now)))
1172 ) {
1173 return providers;
1174 }
1175 // Use scan start for TTL, not checkedAt inherited from the machine health check.
1176 const scannedAt = DateTime.formatIso(now);
1177 const instance = yield* instanceRegistry.getInstance(input.instanceId);
1178 const snapshotForCwd = instance?.snapshotForCwd;
1179 if (!instance || !snapshotForCwd) return providers;
1180 // A report never enrolls a cwd nobody requested, nor outlives the instance that made it.
1181 if (input.rescan && (input.rescan !== instance || (!runningScan && !scannedFrom))) {
1182 return providers;
1183 }
1184 const token = yield* Deferred.make<void>();
1185 // A machine refresh can change this cwd's snapshot, so the scan publishes against the result.
1186 const refreshMachineSnapshot = input.fresh
1187 ? (instance.invalidateCaches ?? Effect.void).pipe(
1188 Effect.andThen(refreshInstance(input.instanceId)),
1189 Effect.andThen(Ref.get(providersRef)),
1190 Effect.map((current) =>
1191 workspaceSnapshotOf(
1192 current.find((candidate) => candidate.instanceId === input.instanceId),
1193 ),
1194 ),
1195 )
1196 : Effect.succeed(scannedFrom);
1197 const runScan = refreshMachineSnapshot.pipe(
1198 Effect.flatMap((scanBase) =>
1199 Effect.map(snapshotForCwd(input.scanCwd ?? input.cwd), (scopedSnapshot) => ({
1200 scanBase,
1201 scopedSnapshot,
1202 })),
1203 ),
1204 // Scans fail on error; returned inventory remains valid even when provider health reports an error.
1205 Effect.flatMap(({ scanBase, scopedSnapshot }) =>
1206 instanceRegistry.getInstance(input.instanceId).pipe(
1207 Effect.flatMap((currentInstance) => {
1208 if (currentInstance !== instance) return Ref.get(providersRef);
1209 return updateProviders((currentProviders) => {
1210 // Read ownership inside the update so a newer claim cannot race publication.
1211 if (Ref.getUnsafe(workspaceRefreshesRef).get(instance)?.get(input.cwd) !== token) {
1212 return currentProviders;
1213 }
1214 return currentProviders.map((candidate) => {
1215 if (
1216 candidate.instanceId !== input.instanceId ||
1217 !Equal.equals(workspaceSnapshotOf(candidate), scanBase)
1218 ) {
1219 return candidate;
1220 }
1221 const scanned = upsertProviderWorkspaceSnapshot(candidate, input.cwd, {
1222 ...scopedSnapshot,
1223 checkedAt: scannedAt,
1224 // Without driver command discovery, retain previous commands after failed health checks and retry.
1225 slashCommandsPending:
1226 scopedSnapshot.slashCommandsPending ?? scopedSnapshot.status === "error",
1227 });
1228 // Clients keep fetched snapshots, so a changed rescan must tell them to fetch again.
1229 const rescanned = workspaceSnapshotOf(scanned);
1230 const held = heldBeforeWait ?? scanBase;
1231 return input.rescan &&
1232 !(
1233 Equal.equals(rescanned?.skills, held?.skills) &&
1234 Equal.equals(rescanned?.slashCommands, held?.slashCommands)
1235 )
1236 ? { ...scanned, workspaceRescannedAt: scannedAt }
1237 : scanned;
1238 });
1239 });
1240 }),
1241 ),
1242 ),
1243 Effect.ensuring(
1244 Ref.update(workspaceRefreshesRef, (refreshes) => {
1245 const current = refreshes.get(instance);
1246 if (current?.get(input.cwd) !== token) return refreshes;
1247 const next = new Map(refreshes);
1248 const nextCwds = new Map(current);
1249 nextCwds.delete(input.cwd);
1250 if (nextCwds.size) next.set(instance, nextCwds);
1251 else next.delete(instance);
1252 return next;
1253 }).pipe(Effect.andThen(Deferred.succeed(token, undefined))),
1254 ),
1255 );
1256 // The claim and the fork happen together, so the token is always completed. The scan is
1257 // detached so a disconnecting owner cannot cancel the result its waiters depend on.
1258 const claim = yield* Effect.uninterruptible(
1259 Effect.gen(function* () {
1260 const inFlight = yield* Ref.modify(workspaceRefreshesRef, (refreshes) => {
1261 const current = refreshes.get(instance);
1262 const running = current?.get(input.cwd);
1263 if (!input.fresh && running) return [running, refreshes] as const;
1264 const next = new Map(refreshes);
1265 next.set(instance, new Map(current).set(input.cwd, token));
1266 return [undefined, next] as const;
1267 });
1268 if (inFlight) return { inFlight } as const;
1269 return {
1270 // Starting now attaches the scan's `ensuring` before anything can close the scope.
1271 scan: yield* Effect.forkIn(runScan, serviceScope, { startImmediately: true }),
1272 } as const;
1273 }),
1274 );
1275 // Wait for the running scan: on-demand clients get its result only in this reply.
1276 if ("inFlight" in claim) {
1277 return yield* Deferred.await(claim.inFlight).pipe(Effect.andThen(Ref.get(providersRef)));
1278 }
1279 return yield* Fiber.join(claim.scan);
1280 });
1281 yield* Stream.runForEach(Stream.fromQueue(workspaceRescans), ({ instance, cwd }) =>
1282 refreshWorkspaceSnapshot({ instanceId: instance.instanceId, cwd, rescan: instance }).pipe(
1283 Effect.ignoreCause({ log: true }),
1284 ),
1285 ).pipe(Effect.forkScoped);
1286
1287 const invalidateModelCaches = Effect.fn("ProviderRegistry.invalidateModelCaches")(function* (
1288 input: Parameters<ProviderRegistry["Service"]["invalidateModelCaches"]>[0],
1289 ) {
1290 yield* manifestService.forceRefresh;
1291 const instances = yield* instanceRegistry.listInstances;
1292 yield* Effect.forEach(
1293 instances.filter(
1294 (instance) => input.instanceId === undefined || input.instanceId === instance.instanceId,
1295 ),
1296 (instance) =>
1297 Effect.gen(function* () {
1298 yield* instance.invalidateCaches ?? Effect.void;
1299 // Instance and full refreshes resolve installer metadata fresh
1300 // themselves; a cached workspace refresh needs it resolved here.
1301 const maintenance = yield* instance.snapshot.resolveMaintenance({
1302 fresh:
1303 input.instanceId !== undefined && input.cwd !== undefined && input.fresh !== true,
1304 });
1305 yield* Effect.forEach(
1306 latestProviderVersionCacheKeys(maintenance),
1307 latestVersions.invalidate,
1308 { discard: true },
1309 );
1310 }),
1311 { concurrency: "unbounded", discard: true },
1312 );
1313 });
1314
1315 const refreshModelCatalog = Effect.fn("ProviderRegistry.refreshModelCatalog")(function* () {
1316 const { updatedAt } = yield* manifestService.refreshOnDemand;
1317 // The first pass can be one that started before the fetch, so allow one more.
1318 for (let pass = 0; pass < 2; pass++) {
1319 if ((yield* Ref.get(probedManifestUpdatedAt)) === updatedAt) return;
1320 // A new model usually ships with the CLI release that supports it.
1321 yield* latestVersions.invalidateAll;
1322 yield* refreshAll();
1323 }
1324 });
1325
1326 return {
1327 getProviders: Ref.get(providersRef),
1328 refresh: (provider?: ProviderDriverKind) =>
1329 refresh(provider).pipe(Effect.catchCause(recoverRefreshFailure)),
1330 refreshInstance: (instanceId: ProviderInstanceId) =>
1331 refreshInstance(instanceId).pipe(Effect.catchCause(recoverRefreshFailure)),
1332 reloadSecretsAndRefresh: (instanceId?: ProviderInstanceId) =>
1333 reloadSecretsAndRefresh(instanceId).pipe(Effect.catchCause(recoverRefreshFailure)),
1334 applySecretAndRefresh: (reference: SecretReference, value: string) =>
1335 applySecretAndRefresh(reference, value).pipe(Effect.catchCause(recoverRefreshFailure)),
1336 refreshWorkspaceSnapshot: (input) =>
1337 refreshWorkspaceSnapshot(input).pipe(Effect.catchCause(recoverRefreshFailure)),
1338 refreshAfterUpdate,
1339 invalidateModelCaches,
1340 refreshModelCatalog: refreshModelCatalog().pipe(
1341 Effect.catchCause(recoverRefreshFailure),
1342 Effect.asVoid,
1343 ),
1344 getProviderMaintenanceCapabilitiesForInstance,
1345 setProviderMaintenanceActionState,
1346 get streamChanges() {
1347 return Stream.fromPubSub(changesPubSub);
1348 },
1349 } satisfies ProviderRegistry["Service"];
1350 }),
1351 );