@devries-cameron20 / t3code-1 / commits / 5fc5a1d095
Fork 0

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

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