The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 18:30 UTC
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({