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 22, 07:00 UTC
fix(server): open clients no longer stay on "Updating" after a provider update (#27992)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Nov 1, 2026 at 21:34 UTC
5fc5a1d095cf7bb324115aed4f3df08581079dfc
2 files changed
+163
-1
apps/server/src/provider/ProviderRegistry.test.ts
+161
@@ -1904,6 +1904,167 @@ it.layer(
1904
}),
1905
);
1906
1907
+ it.effect("streams the terminal update state when it lands during a slow cache write", () =>
1908
+ Effect.gen(function* () {
1909
+ const claudeDriver = ProviderDriverKind.make("claude");
1910
+ const claudeInstanceId = ProviderInstanceId.make("claude");
1911
+ const initialProvider = {
1912
+ instanceId: claudeInstanceId,
1913
+ driver: claudeDriver,
1914
+ status: "ready",
1915
+ enabled: true,
1916
+ installed: true,
1917
+ auth: { status: "authenticated" },
1918
+ checkedAt: "2026-04-14T00:00:00.000Z",
1919
+ version: "2.1.300",
1920
+ models: [],
1921
+ slashCommands: [],
1922
+ skills: [],
1923
+ } as const satisfies ServerProvider;
1924
+ const verifyingProvider = { ...initialProvider, checkedAt: "2026-04-14T00:01:00.000Z" };
1925
+ const laterProvider = { ...initialProvider, checkedAt: "2026-04-14T00:02:00.000Z" };
1926
+ const changes = yield* PubSub.unbounded<ServerProvider>();
1927
+ const instance = {
1928
+ instanceId: claudeInstanceId,
1929
+ driverKind: claudeDriver,
1930
+ continuationIdentity: {
1931
+ driverKind: claudeDriver,
1932
+ continuationKey: "claude:instance:claude",
1933
+ },
1934
+ displayName: undefined,
1935
+ enabled: true,
1936
+ snapshot: {
1937
+ resolveMaintenance: () =>
1938
+ Effect.succeed(
1939
+ makeManualOnlyProviderMaintenanceCapabilities({
1940
+ provider: claudeDriver,
1941
+ packageName: null,
1942
+ }),
1943
+ ),
1944
+ getSnapshot: Effect.succeed(initialProvider),
1945
+ refresh: Effect.succeed(initialProvider),
1946
+ streamChanges: Stream.fromPubSub(changes),
1947
+ applyUsageLimits: () => Effect.void,
1948
+ },
1949
+ orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
1950
+ textGeneration: {} as ProviderInstance["textGeneration"],
1951
+ } satisfies ProviderInstance;
1952
+ const layerInstanceRegistry = Layer.succeed(
1953
+ ProviderInstanceRegistry.ProviderInstanceRegistry,
1954
+ {
1955
+ getInstance: (instanceId) =>
1956
+ Effect.succeed(instanceId === claudeInstanceId ? instance : undefined),
1957
+ listInstances: Effect.succeed([instance]),
1958
+ listUnavailable: Effect.succeed([]),
1959
+ streamChanges: Stream.empty,
1960
+ subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), (pubsub) =>
1961
+ PubSub.subscribe(pubsub),
1962
+ ),
1963
+ },
1964
+ );
1965
+ const writeStarted = yield* Deferred.make<void>();
1966
+ const releaseWrite = yield* Deferred.make<void>();
1967
+ const gatedCachePath = yield* Ref.make<string | undefined>(undefined);
1968
+ const layerGatedFileSystem = Layer.effect(
1969
+ FileSystem.FileSystem,
1970
+ Effect.gen(function* () {
1971
+ const fileSystem = yield* FileSystem.FileSystem;
1972
+ return {
1973
+ ...fileSystem,
1974
+ rename: (from, to) =>
1975
+ Ref.modify(gatedCachePath, (path) =>
1976
+ path === to ? [true, undefined] : [false, path],
1977
+ ).pipe(
1978
+ Effect.flatMap((gated) =>
1979
+ gated
1980
+ ? Deferred.succeed(writeStarted, undefined).pipe(
1981
+ Effect.andThen(Deferred.await(releaseWrite)),
1982
+ )
1983
+ : Effect.void,
1984
+ ),
1985
+ Effect.andThen(fileSystem.rename(from, to)),
1986
+ ),
1987
+ } satisfies FileSystem.FileSystem;
1988
+ }),
1989
+ ).pipe(Layer.provide(NodeServices.layer));
1990
+ const scope = yield* Scope.make();
1991
+ yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
1992
+ const runtimeServices = yield* Layer.build(
1993
+ ProviderRegistry.layer.pipe(
1994
+ Layer.provide(layerUnusedMutator),
1995
+ Layer.provideMerge(layerInstanceRegistry),
1996
+ Layer.provideMerge(
1997
+ ServerConfig.layerTest(process.cwd(), {
1998
+ prefix: "t3-provider-registry-update-state-race-",
1999
+ }),
2000
+ ),
2001
+ Layer.provideMerge(layerBackgroundPolicyAlwaysRun),
2002
+ Layer.provideMerge(layerGatedFileSystem),
2003
+ Layer.provideMerge(NodeServices.layer),
2004
+ ),
2005
+ ).pipe(Scope.provide(scope));
2006
+
2007
+ yield* Effect.gen(function* () {
2008
+ const registry = yield* ProviderRegistry.ProviderRegistry;
2009
+ const config = yield* ServerConfig.ServerConfig;
2010
+ const running = {
2011
+ status: "running",
2012
+ startedAt: "2026-04-14T00:00:30.000Z",
2013
+ finishedAt: null,
2014
+ message: "Verifying the installed version",
2015
+ output: null,
2016
+ } as const;
2017
+ const unchanged = {
2018
+ ...running,
2019
+ status: "unchanged",
2020
+ finishedAt: "2026-04-14T00:01:30.000Z",
2021
+ message:
2022
+ "Update command completed, but T3 Code still detects an outdated provider version.",
2023
+ } as const;
2024
+ yield* registry.setProviderMaintenanceActionState({
2025
+ instanceId: claudeInstanceId,
2026
+ action: "update",
2027
+ state: running,
2028
+ });
2029
+ const streamed = yield* registry.streamChanges.pipe(
2030
+ Stream.takeUntil((providers) =>
2031
+ providers.some((provider) => provider.checkedAt === laterProvider.checkedAt),
2032
+ ),
2033
+ Stream.runCollect,
2034
+ Effect.forkScoped({ startImmediately: true }),
2035
+ );
2036
+
2037
+ yield* Ref.set(
2038
+ gatedCachePath,
2039
+ yield* resolveProviderStatusCachePath({
2040
+ cacheDir: config.providerStatusCacheDir,
2041
+ instanceId: claudeInstanceId,
2042
+ }),
2043
+ );
2044
+ yield* PubSub.publish(changes, verifyingProvider);
2045
+ yield* Deferred.await(writeStarted);
2046
+ yield* registry.setProviderMaintenanceActionState({
2047
+ instanceId: claudeInstanceId,
2048
+ action: "update",
2049
+ state: unchanged,
2050
+ });
2051
+ yield* Deferred.succeed(releaseWrite, undefined);
2052
+ // The snapshot stream is consumed in order, so this lands after the slow write publishes.
2053
+ yield* PubSub.publish(changes, laterProvider);
2054
+
2055
+ const updateStateOf = (providers: ReadonlyArray<ServerProvider> | undefined) =>
2056
+ providers?.find((provider) => provider.instanceId === claudeInstanceId)?.updateState;
2057
+ const beforeLater = (yield* Fiber.join(streamed)).slice(0, -1);
2058
+ assert.deepStrictEqual(updateStateOf(yield* registry.getProviders), unchanged);
2059
+ assert.deepStrictEqual(
2060
+ updateStateOf(beforeLater.at(-1)),
2061
+ unchanged,
2062
+ "the last streamed providers before the next snapshot should carry the terminal update state",
2063
+ );
2064
+ }).pipe(Effect.provide(runtimeServices));
2065
+ }),
2066
+ );
2067
+
2068
it.effect(
2069
"persists authoritative OpenCode removals without resurrecting them on a failed live refresh",
2070
() =>
apps/server/src/provider/ProviderRegistry.ts
+2
-1
@@ -524,7 +524,8 @@ export const layer = Layer.effect(
524
});
525
}
526
if (options?.publish !== false) {
527
- yield* PubSub.publish(changesPubSub, providers);
527
+ // A newer upsert may have committed and published during the cache write; never republish an older array.
528
+ yield* PubSub.publish(changesPubSub, yield* Ref.get(providersRef));
529
}
530
}
531