diff --git a/apps/server/src/provider/ProviderRegistry.test.ts b/apps/server/src/provider/ProviderRegistry.test.ts index 0f6540d439d4b..c0f60b9d77e66 100644 --- a/apps/server/src/provider/ProviderRegistry.test.ts +++ b/apps/server/src/provider/ProviderRegistry.test.ts @@ -35,6 +35,8 @@ import { ServerSettingsError, ServerProvider, type ServerProviderSlashCommand, + type ServerProviderUpdateState, + type ServerProviderVersionAdvisoryStatus, type ServerSettings as ContractServerSettings, } from "@t3tools/contracts"; import { HttpClient, HttpClientResponse } from "effect/http"; @@ -338,6 +340,86 @@ const awaitPersistedProvider = ( Effect.forkScoped, ); +const codexUpdateSnapshot = (advisory: ServerProviderVersionAdvisoryStatus) => + ({ + instanceId: ProviderInstanceId.make("codex"), + driver: ProviderDriverKind.make("codex"), + status: "ready", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + checkedAt: "2026-06-10T00:00:00.000Z", + version: "1.0.0", + models: [], + slashCommands: [], + skills: [], + versionAdvisory: { + status: advisory, + currentVersion: "1.0.0", + latestVersion: advisory === "unknown" ? null : advisory === "current" ? "1.0.0" : "2.0.0", + updateCommand: null, + canUpdate: true, + checkedAt: "2026-06-10T00:00:00.000Z", + message: null, + }, + }) as const satisfies ServerProvider; + +const makeUpdateState = (status: ServerProviderUpdateState["status"]) => + ({ + status, + startedAt: "2026-06-10T00:00:00.000Z", + finishedAt: status === "queued" || status === "running" ? null : "2026-06-10T00:01:00.000Z", + message: `update ${status}`, + output: null, + }) satisfies ServerProviderUpdateState; + +// One Codex instance whose probe returns whatever `snapshot` currently holds. +const buildRegistryOverSnapshot = Effect.fn("buildRegistryOverSnapshot")(function* ( + snapshot: Ref.Ref, +) { + const driver = ProviderDriverKind.make("codex"); + const instance = { + instanceId: ProviderInstanceId.make("codex"), + driverKind: driver, + continuationIdentity: { driverKind: driver, continuationKey: "codex:instance:codex" }, + displayName: undefined, + enabled: true, + snapshot: { + resolveMaintenance: () => + Effect.succeed( + makeManualOnlyProviderMaintenanceCapabilities({ provider: driver, packageName: null }), + ), + getSnapshot: Ref.get(snapshot), + refresh: Ref.get(snapshot), + streamChanges: Stream.empty, + applyUsageLimits: () => Effect.void, + }, + orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"], + textGeneration: {} as ProviderInstance["textGeneration"], + } satisfies ProviderInstance; + const layerInstanceRegistry = Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, { + getInstance: (instanceId) => + Effect.succeed(instanceId === instance.instanceId ? instance : undefined), + listInstances: Effect.succeed([instance]), + listUnavailable: Effect.succeed([]), + streamChanges: Stream.empty, + subscribeChanges: Effect.flatMap(PubSub.unbounded(), PubSub.subscribe), + }); + const scope = yield* Scope.make(); + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void)); + return yield* Layer.build( + ProviderRegistry.layer.pipe( + Layer.provide(layerUnusedMutator), + Layer.provideMerge(layerInstanceRegistry), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { prefix: "t3-provider-registry-update-state-" }), + ), + Layer.provideMerge(layerBackgroundPolicyAlwaysRun), + Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), + ), + ).pipe(Scope.provide(scope)); +}); + const layerTestNodeServices = Layer.mergeAll( ProviderLatestVersions.layer, NodeServices.layer, @@ -3280,6 +3362,67 @@ it.layer( }), ); + describe("update results across refreshes", () => { + const instanceId = ProviderInstanceId.make("codex"); + + it.effect.each([ + { status: "unchanged", advisory: "current", retired: true }, + { status: "failed", advisory: "current", retired: true }, + { status: "unchanged", advisory: "behind_latest", retired: false }, + { status: "failed", advisory: "behind_latest", retired: false }, + // The probe publishes `unknown` until the latest-version check lands. + { status: "unchanged", advisory: "unknown", retired: false }, + { status: "queued", advisory: "current", retired: false }, + { status: "running", advisory: "current", retired: false }, + { status: "succeeded", advisory: "current", retired: false }, + { status: "failed", advisory: "unknown", retired: false }, + ] as const)( + "a $status update result is retired: $retired when a refresh reports the provider $advisory", + ({ status, advisory, retired }) => + Effect.gen(function* () { + const snapshot = yield* Ref.make(codexUpdateSnapshot("behind_latest")); + const runtimeServices = yield* buildRegistryOverSnapshot(snapshot); + + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + const state = makeUpdateState(status); + yield* registry.setProviderMaintenanceActionState({ + instanceId, + action: "update", + state, + }); + yield* Ref.set(snapshot, codexUpdateSnapshot(advisory)); + + const [refreshed] = yield* registry.refresh(ProviderDriverKind.make("codex")); + + expect(refreshed?.updateState).toEqual(retired ? undefined : state); + }).pipe(Effect.provide(runtimeServices)); + }), + ); + + it.effect.each(["failed", "unchanged"] as const)( + "keeps a %s recommended-version install after a current refresh", + (status) => + Effect.gen(function* () { + const snapshot = yield* Ref.make(codexUpdateSnapshot("current")); + const runtimeServices = yield* buildRegistryOverSnapshot(snapshot); + yield* Effect.gen(function* () { + const registry = yield* ProviderRegistry.ProviderRegistry; + const state = makeUpdateState(status); + const input = { + instanceId, + action: "update" as const, + state, + targetVersion: "0.9.0", + }; + yield* registry.setProviderMaintenanceActionState(input); + const [refreshed] = yield* registry.refresh(ProviderDriverKind.make("codex")); + expect(refreshed?.updateState).toEqual(state); + }).pipe(Effect.provide(runtimeServices)); + }), + ); + }); + it.effect("re-probes when settings change the codex binaryPath", () => Effect.gen(function* () { const firstMissing = `t3code_codex_first_`; diff --git a/apps/server/src/provider/ProviderRegistry.ts b/apps/server/src/provider/ProviderRegistry.ts index b2d9ba8af27a2..ba9ce9b2b6af7 100644 --- a/apps/server/src/provider/ProviderRegistry.ts +++ b/apps/server/src/provider/ProviderRegistry.ts @@ -118,6 +118,7 @@ export class ProviderRegistry extends Context.Service< readonly instanceId: ProviderInstanceId; readonly action: ProviderMaintenanceActionKind; readonly state: ServerProviderUpdateState | null; + readonly targetVersion?: string | undefined; }) => Effect.Effect>; readonly streamChanges: Stream.Stream>; @@ -479,7 +480,10 @@ export const layer = Layer.effect( ReadonlyMap>> >(new Map()); const maintenanceActionStatesRef = yield* Ref.make< - ReadonlyMap + ReadonlyMap< + ProviderInstanceId, + { readonly update?: ServerProviderUpdateState; readonly targetVersion?: string | undefined } + > >(new Map()); const liveSubsRef = yield* Ref.make>( @@ -599,6 +603,21 @@ export const layer = Layer.effect( readonly publish?: boolean; }, ) { + // Latest-version status cannot resolve a failed recommended-version install. + if (provider.versionAdvisory?.status === "current") { + yield* Ref.update(maintenanceActionStatesRef, (previous) => { + const action = previous.get(provider.instanceId); + if ( + action?.targetVersion !== undefined || + (action?.update?.status !== "unchanged" && action?.update?.status !== "failed") + ) { + return previous; + } + const next = new Map(previous); + next.delete(provider.instanceId); + return next; + }); + } const providers = yield* upsertProviders([provider], options); yield* refreshCompatibility; return providers; @@ -609,21 +628,14 @@ export const layer = Layer.effect( readonly instanceId: ProviderInstanceId; readonly action: "update"; readonly state: ServerProviderUpdateState | null; + readonly targetVersion?: string | undefined; }) { yield* Ref.update(maintenanceActionStatesRef, (previous) => { - const previousActions = previous.get(input.instanceId); - const nextActions = { ...previousActions }; - if (input.state === null || input.state.status === "idle") { - delete nextActions[input.action]; - } else { - nextActions[input.action] = input.state; - } - const next = new Map(previous); - if (Object.keys(nextActions).length === 0) { + if (input.state === null || input.state.status === "idle") { next.delete(input.instanceId); } else { - next.set(input.instanceId, nextActions); + next.set(input.instanceId, { update: input.state, targetVersion: input.targetVersion }); } return next; }); diff --git a/apps/server/src/provider/providerMaintenanceRunner.ts b/apps/server/src/provider/providerMaintenanceRunner.ts index 80248acea577e..9ac62dca70419 100644 --- a/apps/server/src/provider/providerMaintenanceRunner.ts +++ b/apps/server/src/provider/providerMaintenanceRunner.ts @@ -450,6 +450,7 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () { instanceId, action: "update", state, + targetVersion, }); const setQueuedState = setUpdateState( makeUpdateState({