@devries-cameron20 / t3code-1 / commits / 13034bfad2
Fork 0

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

fix(server): stale provider update results clear once the provider is up to date (#24338)

Co-authored-by: maria-rcks <maria@kuuro.net> Co-authored-by: Julius Marminge <julius0216@outlook.com>

fixfon committed Nov 13, 2026 at 01:49 UTC 13034bfad2f7587f6055901b423ff03b4c5ad078
3 files changed +167 -11
apps/server/src/provider/ProviderRegistry.test.ts
+143
@@ -35,6 +35,8 @@ import {
35 ServerSettingsError,
36 ServerProvider,
37 type ServerProviderSlashCommand,
38 + type ServerProviderUpdateState,
39 + type ServerProviderVersionAdvisoryStatus,
40 type ServerSettings as ContractServerSettings,
41 } from "@t3tools/contracts";
42 import { HttpClient, HttpClientResponse } from "effect/http";
@@ -338,6 +340,86 @@ const awaitPersistedProvider = (
340 Effect.forkScoped,
341 );
342
343 +const codexUpdateSnapshot = (advisory: ServerProviderVersionAdvisoryStatus) =>
344 + ({
345 + instanceId: ProviderInstanceId.make("codex"),
346 + driver: ProviderDriverKind.make("codex"),
347 + status: "ready",
348 + enabled: true,
349 + installed: true,
350 + auth: { status: "authenticated" },
351 + checkedAt: "2026-06-10T00:00:00.000Z",
352 + version: "1.0.0",
353 + models: [],
354 + slashCommands: [],
355 + skills: [],
356 + versionAdvisory: {
357 + status: advisory,
358 + currentVersion: "1.0.0",
359 + latestVersion: advisory === "unknown" ? null : advisory === "current" ? "1.0.0" : "2.0.0",
360 + updateCommand: null,
361 + canUpdate: true,
362 + checkedAt: "2026-06-10T00:00:00.000Z",
363 + message: null,
364 + },
365 + }) as const satisfies ServerProvider;
366 +
367 +const makeUpdateState = (status: ServerProviderUpdateState["status"]) =>
368 + ({
369 + status,
370 + startedAt: "2026-06-10T00:00:00.000Z",
371 + finishedAt: status === "queued" || status === "running" ? null : "2026-06-10T00:01:00.000Z",
372 + message: `update ${status}`,
373 + output: null,
374 + }) satisfies ServerProviderUpdateState;
375 +
376 +// One Codex instance whose probe returns whatever `snapshot` currently holds.
377 +const buildRegistryOverSnapshot = Effect.fn("buildRegistryOverSnapshot")(function* (
378 + snapshot: Ref.Ref<ServerProvider>,
379 +) {
380 + const driver = ProviderDriverKind.make("codex");
381 + const instance = {
382 + instanceId: ProviderInstanceId.make("codex"),
383 + driverKind: driver,
384 + continuationIdentity: { driverKind: driver, continuationKey: "codex:instance:codex" },
385 + displayName: undefined,
386 + enabled: true,
387 + snapshot: {
388 + resolveMaintenance: () =>
389 + Effect.succeed(
390 + makeManualOnlyProviderMaintenanceCapabilities({ provider: driver, packageName: null }),
391 + ),
392 + getSnapshot: Ref.get(snapshot),
393 + refresh: Ref.get(snapshot),
394 + streamChanges: Stream.empty,
395 + applyUsageLimits: () => Effect.void,
396 + },
397 + orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
398 + textGeneration: {} as ProviderInstance["textGeneration"],
399 + } satisfies ProviderInstance;
400 + const layerInstanceRegistry = Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, {
401 + getInstance: (instanceId) =>
402 + Effect.succeed(instanceId === instance.instanceId ? instance : undefined),
403 + listInstances: Effect.succeed([instance]),
404 + listUnavailable: Effect.succeed([]),
405 + streamChanges: Stream.empty,
406 + subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),
407 + });
408 + const scope = yield* Scope.make();
409 + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
410 + return yield* Layer.build(
411 + ProviderRegistry.layer.pipe(
412 + Layer.provide(layerUnusedMutator),
413 + Layer.provideMerge(layerInstanceRegistry),
414 + Layer.provideMerge(
415 + ServerConfig.layerTest(process.cwd(), { prefix: "t3-provider-registry-update-state-" }),
416 + ),
417 + Layer.provideMerge(layerBackgroundPolicyAlwaysRun),
418 + Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
419 + ),
420 + ).pipe(Scope.provide(scope));
421 +});
422 +
423 const layerTestNodeServices = Layer.mergeAll(
424 ProviderLatestVersions.layer,
425 NodeServices.layer,
@@ -3280,6 +3362,67 @@ it.layer(
3362 }),
3363 );
3364
3365 + describe("update results across refreshes", () => {
3366 + const instanceId = ProviderInstanceId.make("codex");
3367 +
3368 + it.effect.each([
3369 + { status: "unchanged", advisory: "current", retired: true },
3370 + { status: "failed", advisory: "current", retired: true },
3371 + { status: "unchanged", advisory: "behind_latest", retired: false },
3372 + { status: "failed", advisory: "behind_latest", retired: false },
3373 + // The probe publishes `unknown` until the latest-version check lands.
3374 + { status: "unchanged", advisory: "unknown", retired: false },
3375 + { status: "queued", advisory: "current", retired: false },
3376 + { status: "running", advisory: "current", retired: false },
3377 + { status: "succeeded", advisory: "current", retired: false },
3378 + { status: "failed", advisory: "unknown", retired: false },
3379 + ] as const)(
3380 + "a $status update result is retired: $retired when a refresh reports the provider $advisory",
3381 + ({ status, advisory, retired }) =>
3382 + Effect.gen(function* () {
3383 + const snapshot = yield* Ref.make<ServerProvider>(codexUpdateSnapshot("behind_latest"));
3384 + const runtimeServices = yield* buildRegistryOverSnapshot(snapshot);
3385 +
3386 + yield* Effect.gen(function* () {
3387 + const registry = yield* ProviderRegistry.ProviderRegistry;
3388 + const state = makeUpdateState(status);
3389 + yield* registry.setProviderMaintenanceActionState({
3390 + instanceId,
3391 + action: "update",
3392 + state,
3393 + });
3394 + yield* Ref.set(snapshot, codexUpdateSnapshot(advisory));
3395 +
3396 + const [refreshed] = yield* registry.refresh(ProviderDriverKind.make("codex"));
3397 +
3398 + expect(refreshed?.updateState).toEqual(retired ? undefined : state);
3399 + }).pipe(Effect.provide(runtimeServices));
3400 + }),
3401 + );
3402 +
3403 + it.effect.each(["failed", "unchanged"] as const)(
3404 + "keeps a %s recommended-version install after a current refresh",
3405 + (status) =>
3406 + Effect.gen(function* () {
3407 + const snapshot = yield* Ref.make<ServerProvider>(codexUpdateSnapshot("current"));
3408 + const runtimeServices = yield* buildRegistryOverSnapshot(snapshot);
3409 + yield* Effect.gen(function* () {
3410 + const registry = yield* ProviderRegistry.ProviderRegistry;
3411 + const state = makeUpdateState(status);
3412 + const input = {
3413 + instanceId,
3414 + action: "update" as const,
3415 + state,
3416 + targetVersion: "0.9.0",
3417 + };
3418 + yield* registry.setProviderMaintenanceActionState(input);
3419 + const [refreshed] = yield* registry.refresh(ProviderDriverKind.make("codex"));
3420 + expect(refreshed?.updateState).toEqual(state);
3421 + }).pipe(Effect.provide(runtimeServices));
3422 + }),
3423 + );
3424 + });
3425 +
3426 it.effect("re-probes when settings change the codex binaryPath", () =>
3427 Effect.gen(function* () {
3428 const firstMissing = `t3code_codex_first_`;
apps/server/src/provider/ProviderRegistry.ts
+23 -11
@@ -118,6 +118,7 @@ export class ProviderRegistry extends Context.Service<
118 readonly instanceId: ProviderInstanceId;
119 readonly action: ProviderMaintenanceActionKind;
120 readonly state: ServerProviderUpdateState | null;
121 + readonly targetVersion?: string | undefined;
122 }) => Effect.Effect<ReadonlyArray<ServerProvider>>;
123
124 readonly streamChanges: Stream.Stream<ReadonlyArray<ServerProvider>>;
@@ -479,7 +480,10 @@ export const layer = Layer.effect(
480 ReadonlyMap<ProviderInstance, ReadonlyMap<string, Deferred.Deferred<void>>>
481 >(new Map());
482 const maintenanceActionStatesRef = yield* Ref.make<
482 - ReadonlyMap<ProviderInstanceId, { readonly update?: ServerProviderUpdateState | undefined }>
483 + ReadonlyMap<
484 + ProviderInstanceId,
485 + { readonly update?: ServerProviderUpdateState; readonly targetVersion?: string | undefined }
486 + >
487 >(new Map());
488
489 const liveSubsRef = yield* Ref.make<ReadonlyMap<ProviderInstanceId, ProviderInstance>>(
@@ -599,6 +603,21 @@ export const layer = Layer.effect(
603 readonly publish?: boolean;
604 },
605 ) {
606 + // Latest-version status cannot resolve a failed recommended-version install.
607 + if (provider.versionAdvisory?.status === "current") {
608 + yield* Ref.update(maintenanceActionStatesRef, (previous) => {
609 + const action = previous.get(provider.instanceId);
610 + if (
611 + action?.targetVersion !== undefined ||
612 + (action?.update?.status !== "unchanged" && action?.update?.status !== "failed")
613 + ) {
614 + return previous;
615 + }
616 + const next = new Map(previous);
617 + next.delete(provider.instanceId);
618 + return next;
619 + });
620 + }
621 const providers = yield* upsertProviders([provider], options);
622 yield* refreshCompatibility;
623 return providers;
@@ -609,21 +628,14 @@ export const layer = Layer.effect(
628 readonly instanceId: ProviderInstanceId;
629 readonly action: "update";
630 readonly state: ServerProviderUpdateState | null;
631 + readonly targetVersion?: string | undefined;
632 }) {
633 yield* Ref.update(maintenanceActionStatesRef, (previous) => {
614 - const previousActions = previous.get(input.instanceId);
615 - const nextActions = { ...previousActions };
616 - if (input.state === null || input.state.status === "idle") {
617 - delete nextActions[input.action];
618 - } else {
619 - nextActions[input.action] = input.state;
620 - }
621 -
634 const next = new Map(previous);
623 - if (Object.keys(nextActions).length === 0) {
635 + if (input.state === null || input.state.status === "idle") {
636 next.delete(input.instanceId);
637 } else {
626 - next.set(input.instanceId, nextActions);
638 + next.set(input.instanceId, { update: input.state, targetVersion: input.targetVersion });
639 }
640 return next;
641 });
apps/server/src/provider/providerMaintenanceRunner.ts
+1
@@ -450,6 +450,7 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
450 instanceId,
451 action: "update",
452 state,
453 + targetVersion,
454 });
455 const setQueuedState = setUpdateState(
456 makeUpdateState({