The best way to control Claude Code, Codex and more from any computer or phone
fix(server): Homebrew installs no longer run brew info with update checks off (#19581)
Co-authored-by: Julius Marminge <julius0216@outlook.com>
Tristan Knight committed
Oct 20, 2026 at 07:34 UTC
b39f45696e0633872aeccaaa8e9e000c772efd35
7 files changed
+237
-40
apps/server/src/provider/providerMaintenanceRunner.test.ts
+67
@@ -1082,6 +1082,73 @@ it.effect.each([
1082
},
1083
);
1084
1085
+it.effect(
1086
+ "uses fresh installer versions for post-update verification and compatibility checks",
1087
+ () => {
1088
+ const calls: string[] = [];
1089
+ let latest = "1.0.0";
1090
+ const manifest: ModelManifest.ModelManifestData = {
1091
+ version: 1,
1092
+ currentModels: {},
1093
+ compatibility: [
1094
+ {
1095
+ driver: "codex",
1096
+ t3CodeRange: ">=0.0.42",
1097
+ ranges: [
1098
+ { range: "<=2.0.0", status: "supported" },
1099
+ { range: ">2.0.0", status: "broken" },
1100
+ ],
1101
+ },
1102
+ ],
1103
+ };
1104
+ return Effect.gen(function* () {
1105
+ const { registry } = yield* makeRegistry({ ...baseProvider, version: "1.0.0" });
1106
+ const capabilities = makeProviderMaintenanceCapabilities({
1107
+ provider: CODEX_DRIVER,
1108
+ packageName: "@openai/codex",
1109
+ updateExecutable: "/opt/homebrew/bin/brew",
1110
+ updateArgs: ["upgrade", "--cask", "codex"],
1111
+ updateLockKey: "homebrew",
1112
+ latestVersion: null,
1113
+ lookupLatestVersion: Effect.sync(() => latest),
1114
+ });
1115
+ const updater = yield* makeTestRunner(
1116
+ {
1117
+ ...registry,
1118
+ getProviderMaintenanceCapabilitiesForInstance: () => Effect.succeed(capabilities),
1119
+ },
1120
+ manifest,
1121
+ );
1122
+
1123
+ const unchanged = yield* updater.updateProvider(CODEX_DRIVER);
1124
+ assert.strictEqual(unchanged.providers[0]?.updateState?.status, "unchanged");
1125
+ assert.match(unchanged.providers[0]?.updateState?.message ?? "", /outdated provider version/);
1126
+ assert.deepStrictEqual(calls, ["upgrade --cask codex"]);
1127
+
1128
+ latest = "3.0.0";
1129
+ const refused = yield* updater.updateProvider(CODEX_DRIVER);
1130
+ assert.strictEqual(refused.providers[0]?.updateState?.status, "failed");
1131
+ assert.match(refused.providers[0]?.updateState?.message ?? "", /incompatible/);
1132
+ assert.deepStrictEqual(calls, ["upgrade --cask codex"]);
1133
+ }).pipe(
1134
+ Effect.provide(
1135
+ Layer.mergeAll(
1136
+ layerNonWindowsPlatform,
1137
+ Layer.succeed(
1138
+ HttpClient.HttpClient,
1139
+ HttpClient.make(() => Effect.die("Homebrew's latest should not come from npm")),
1140
+ ),
1141
+ layerMockSpawner((_command, args) => {
1142
+ calls.push(args.join(" "));
1143
+ latest = "2.0.0";
1144
+ return { stdout: "upgraded" };
1145
+ }),
1146
+ ),
1147
+ ),
1148
+ );
1149
+ },
1150
+);
1151
+
1152
it.effect("refuses incompatible latest versions and unapproved or unpinnable targets", () => {
1153
const calls: string[] = [];
1154
const manifest: ModelManifest.ModelManifestData = {
apps/server/src/provider/providerMaintenanceRunner.ts
+7
-2
@@ -30,6 +30,7 @@ import * as ProviderRegistry from "./ProviderRegistry.ts";
30
import { makeProviderMaintenanceCommandCoordinator } from "./providerMaintenanceCommandCoordinator.ts";
31
import {
32
enrichProviderSnapshotWithVersionAdvisory,
33
+ invalidateLatestProviderVersion,
34
makeTargetedProviderUpdateAction,
35
resolveLatestProviderUpdateAction,
36
resolveLatestProviderVersion,
@@ -428,9 +429,11 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
429
}
430
431
const manifest = yield* manifestService.current;
432
+ // Check compatibility against what an unpinned command would install now.
433
const candidateVersion =
434
targetVersion ??
433
- (yield* resolveLatestProviderVersion(fresh).pipe(
435
+ (yield* invalidateLatestProviderVersion(fresh).pipe(
436
+ Effect.andThen(resolveLatestProviderVersion(fresh)),
437
Effect.provideService(HttpClient.HttpClient, httpClient),
438
Effect.provideService(
439
ProviderLatestVersions.ProviderLatestVersions,
@@ -483,12 +486,14 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
486
}
487
488
yield* setRunningMessage("Verifying the installed version");
486
- // Homebrew's "latest" moves once the upgrade lands; read it again.
489
const verified = yield* providerRegistry.getProviderMaintenanceCapabilitiesForInstance(
490
instanceId,
491
provider,
492
{ fresh: true },
493
);
494
+ yield* invalidateLatestProviderVersion(verified).pipe(
495
+ Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, latestVersions),
496
+ );
497
const { verifiedProviders } = yield* verifyRefreshedProvider(
498
provider,
499
verified,
packages/provider-core/src/server/ProviderLatestVersions.ts
+6
-1
@@ -38,10 +38,15 @@ export const make = Effect.fn("ProviderLatestVersions.make")(function* (
38
const now = DateTime.toEpochMillis(yield* DateTime.now);
39
const existing = (yield* Ref.get(entries)).get(key);
40
if (!options?.fresh && existing && existing.expiresAt > now) return existing.version;
41
+ // Replacing or invalidating this entry retires any lookup still in flight.
42
+ const pending = { version: null, expiresAt: 0 };
43
+ yield* Ref.update(entries, (current) => new Map(current).set(key, pending));
44
const version = yield* lookup;
45
const ttl = version === null ? MISSING_TTL : FOUND_TTL;
46
yield* Ref.update(entries, (current) =>
44
- new Map(current).set(key, { version, expiresAt: now + Duration.toMillis(ttl) }),
47
+ current.get(key) === pending
48
+ ? new Map(current).set(key, { version, expiresAt: now + Duration.toMillis(ttl) })
49
+ : current,
50
);
51
return version;
52
}),
packages/provider-core/src/server/maintenance.ts
+2
-1
@@ -12,7 +12,8 @@ export interface ProviderMaintenanceCapabilities {
12
*/
13
readonly latestVersion?: string | null;
14
/**
15
- * Deferred until update checks are enabled; `null` falls back to npm.
15
+ * Deferred until update checks are enabled; `null` falls back to
16
+ * `latestVersion`, then npm.
17
*/
18
readonly lookupLatestVersion?: Effect.Effect<string | null>;
19
readonly compareVersions?: (current: string, latest: string) => number;
packages/provider-core/src/server/maintenanceResolver.test.ts
+114
-18
@@ -21,6 +21,7 @@ import {
21
makeTargetedProviderUpdateAction,
22
enrichProviderSnapshotWithVersionAdvisory,
23
homebrewOwnershipFromCommandPath,
24
+ invalidateLatestProviderVersion,
25
makeCachedProviderMaintenanceResolution,
26
makePackageManagedProviderMaintenanceResolver,
27
makeProviderMaintenanceCapabilities,
@@ -1064,14 +1065,9 @@ it.layer(NodeServices.layer)("providerMaintenance", (it) => {
1065
),
1066
);
1067
1067
- expect(spawned).toEqual([
1068
- [brewPath, "--prefix"],
1069
- [brewPath, "info", "--json=v2", fixture.name],
1070
- ]);
1071
- expect(capabilities).toEqual({
1068
+ expect(capabilities).toMatchObject({
1069
provider: driver("packageTool"),
1070
packageName: "@example/package-tool",
1074
- latestVersion: fixture.latestVersion,
1071
update: {
1072
command:
1073
fixture.kind === "cask"
@@ -1086,29 +1082,129 @@ it.layer(NodeServices.layer)("providerMaintenance", (it) => {
1082
},
1083
});
1084
1089
- const provider = yield* enrichProviderSnapshotWithVersionAdvisory(
1090
- { ...installedPackageToolProvider, version: "0.148.0" },
1091
- capabilities,
1092
- ).pipe(
1093
- Effect.provide(ProviderLatestVersions.layer),
1094
- Effect.provideService(
1095
- HttpClient.HttpClient,
1096
- HttpClient.make(() =>
1097
- Effect.die("Homebrew version checks should not fall back to npm"),
1085
+ const enrich = (enableProviderUpdateChecks: boolean) =>
1086
+ enrichProviderSnapshotWithVersionAdvisory(
1087
+ { ...installedPackageToolProvider, version: "0.148.0" },
1088
+ capabilities,
1089
+ { enableProviderUpdateChecks },
1090
+ ).pipe(
1091
+ Effect.provide(ProviderLatestVersions.layer),
1092
+ Effect.provideService(
1093
+ HttpClient.HttpClient,
1094
+ HttpClient.make(() =>
1095
+ Effect.die("Homebrew version checks should not fall back to npm"),
1096
+ ),
1097
),
1099
- ),
1100
- );
1098
+ );
1099
1102
- expect(provider.versionAdvisory).toMatchObject({
1100
+ expect((yield* enrich(false)).versionAdvisory).toMatchObject({
1101
+ status: "unknown",
1102
+ latestVersion: null,
1103
+ });
1104
+ expect(spawned).toEqual([[brewPath, "--prefix"]]);
1105
+
1106
+ expect((yield* enrich(true)).versionAdvisory).toMatchObject({
1107
status: fixture.latestVersion === null ? "unknown" : "current",
1108
latestVersion: fixture.latestVersion,
1109
canUpdate: true,
1110
message: null,
1111
});
1112
+ expect(spawned).toEqual([
1113
+ [brewPath, "--prefix"],
1114
+ [brewPath, "info", "--json=v2", fixture.name],
1115
+ ]);
1116
}),
1117
{ skip: !symlinksSupported },
1118
);
1119
1120
+ it.effect("shares installer lookups only for the same executable and update target", () =>
1121
+ Effect.gen(function* () {
1122
+ let lookups = 0;
1123
+ const capabilities = (executable: string, args: ReadonlyArray<string>, version: string) =>
1124
+ makeProviderMaintenanceCapabilities({
1125
+ provider: driver("packageTool"),
1126
+ packageName: "@example/package-tool",
1127
+ updateExecutable: executable,
1128
+ updateArgs: args,
1129
+ updateLockKey: "homebrew",
1130
+ latestVersion: null,
1131
+ lookupLatestVersion: Effect.sync(() => {
1132
+ lookups += 1;
1133
+ return version;
1134
+ }),
1135
+ });
1136
+
1137
+ const formula = capabilities("/opt/homebrew/bin/brew", ["upgrade", "package-tool"], "2.0.0");
1138
+ const cask = capabilities(
1139
+ "/opt/homebrew/bin/brew",
1140
+ ["upgrade", "--cask", "package-tool"],
1141
+ "3.0.0",
1142
+ );
1143
+ const otherBrew = capabilities("/usr/local/bin/brew", ["upgrade", "package-tool"], "4.0.0");
1144
+
1145
+ expect(yield* resolveLatestProviderVersion(formula)).toBe("2.0.0");
1146
+ expect(yield* resolveLatestProviderVersion(cask)).toBe("3.0.0");
1147
+ expect(yield* resolveLatestProviderVersion(otherBrew)).toBe("4.0.0");
1148
+ const refreshed = capabilities(
1149
+ "/opt/homebrew/bin/brew",
1150
+ ["upgrade", "package-tool"],
1151
+ "5.0.0",
1152
+ );
1153
+ expect(yield* resolveLatestProviderVersion(refreshed)).toBe("2.0.0");
1154
+ expect(lookups).toBe(3);
1155
+
1156
+ yield* invalidateLatestProviderVersion(refreshed);
1157
+ expect(yield* resolveLatestProviderVersion(refreshed)).toBe("5.0.0");
1158
+ expect(yield* resolveLatestProviderVersion(cask)).toBe("3.0.0");
1159
+ expect(yield* resolveLatestProviderVersion(otherBrew)).toBe("4.0.0");
1160
+ expect(lookups).toBe(4);
1161
+ }).pipe(
1162
+ Effect.provide(ProviderLatestVersions.layer),
1163
+ Effect.provideService(
1164
+ HttpClient.HttpClient,
1165
+ HttpClient.make(() => Effect.die("Homebrew's latest should not come from npm")),
1166
+ ),
1167
+ ),
1168
+ );
1169
+
1170
+ it.effect(
1171
+ "refreshes installer versions without letting an older lookup overwrite the result",
1172
+ () =>
1173
+ Effect.gen(function* () {
1174
+ const started = yield* Deferred.make<void>();
1175
+ const release = yield* Deferred.make<string>();
1176
+ let lookups = 0;
1177
+ const capabilities = makeProviderMaintenanceCapabilities({
1178
+ provider: driver("packageTool"),
1179
+ packageName: "@example/package-tool",
1180
+ updateExecutable: "/opt/homebrew/bin/brew",
1181
+ updateArgs: ["upgrade", "package-tool"],
1182
+ updateLockKey: "homebrew",
1183
+ latestVersion: null,
1184
+ lookupLatestVersion: Effect.suspend(() =>
1185
+ ++lookups === 1
1186
+ ? Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(release)))
1187
+ : Effect.succeed("2.0.0"),
1188
+ ),
1189
+ });
1190
+ const pending = yield* resolveLatestProviderVersion(capabilities).pipe(Effect.forkChild);
1191
+ yield* Deferred.await(started);
1192
+ yield* invalidateLatestProviderVersion(capabilities);
1193
+ expect(yield* resolveLatestProviderVersion(capabilities)).toBe("2.0.0");
1194
+
1195
+ yield* Deferred.succeed(release, "1.0.0");
1196
+ expect(yield* Fiber.join(pending)).toBe("1.0.0");
1197
+ expect(yield* resolveLatestProviderVersion(capabilities)).toBe("2.0.0");
1198
+ expect(lookups).toBe(2);
1199
+ }).pipe(
1200
+ Effect.provide(ProviderLatestVersions.layer),
1201
+ Effect.provideService(
1202
+ HttpClient.HttpClient,
1203
+ HttpClient.make(() => Effect.die("Homebrew's latest should not come from npm")),
1204
+ ),
1205
+ ),
1206
+ );
1207
+
1208
it.effect.skipIf(windowsHost)(
1209
"stays manual-only when the keg is not under the resolved brew's prefix",
1210
() =>
packages/provider-core/src/server/maintenanceResolver.ts
+35
-16
@@ -589,8 +589,8 @@ export const resolvePackageManagedProviderMaintenance = Effect.fn(
589
590
/**
591
* `brew upgrade` capabilities once the keg's prefix is confirmed by a `brew`
592
- * that reports it as its own, with `latestVersion` from `brew info`. Null when
593
- * no `brew` is found or it owns another prefix.
592
+ * that reports it as its own. Version checks defer `brew info` until needed.
593
+ * Null when no `brew` is found or it owns another prefix.
594
*/
595
export const resolveHomebrewProviderMaintenance = Effect.fn("resolveHomebrewProviderMaintenance")(
596
function* (
@@ -621,9 +621,7 @@ export const resolveHomebrewProviderMaintenance = Effect.fn("resolveHomebrewProv
621
}
622
const args =
623
homebrew.kind === "cask" ? ["upgrade", "--cask", homebrew.name] : ["upgrade", homebrew.name];
624
- // Homebrew lags npm by hours on every release, so compare against what
625
- // `brew upgrade` can actually deliver.
626
- const info = yield* runProbe(brewPath, ["info", "--json=v2", homebrew.name], context.env);
624
+ const services = yield* Effect.context<ProviderMaintenanceResolverServices>();
625
return makeProviderMaintenanceCapabilities({
626
provider: input.provider,
627
packageName: input.packageName,
@@ -631,7 +629,16 @@ export const resolveHomebrewProviderMaintenance = Effect.fn("resolveHomebrewProv
629
updateArgs: args,
630
updateLockKey: "homebrew",
631
updateCommand: ["brew", ...args].join(" "),
634
- latestVersion: info ? parseHomebrewLatestVersion(info, homebrew) : null,
632
+ // Brew's release can lag npm; only its own channel can say what upgrade installs.
633
+ latestVersion: null,
634
+ lookupLatestVersion: runProbe(
635
+ brewPath,
636
+ ["info", "--json=v2", homebrew.name],
637
+ context.env,
638
+ ).pipe(
639
+ Effect.map((info) => (info ? parseHomebrewLatestVersion(info, homebrew) : null)),
640
+ Effect.provideContext(services),
641
+ ),
642
});
643
},
644
);
@@ -865,8 +872,9 @@ const fetchNpmLatestVersion = Effect.fn("fetchNpmLatestVersion")(function* (pack
872
873
/** The installer's own answer is cached apart from the npm registry entry. */
874
function installerLatestVersionKey(capabilities: ProviderMaintenanceCapabilities) {
868
- return capabilities.lookupLatestVersion && capabilities.update && capabilities.packageName
869
- ? `${capabilities.update.lockKey}:${capabilities.packageName}`
875
+ const update = capabilities.update;
876
+ return capabilities.lookupLatestVersion && update
877
+ ? [update.lockKey, update.executable, ...update.args].join("\0")
878
: null;
879
}
880
@@ -881,14 +889,6 @@ export function latestProviderVersionCacheKeys(
889
export const resolveLatestProviderVersion = Effect.fn("resolveLatestProviderVersion")(function* (
890
maintenanceCapabilities: ProviderMaintenanceCapabilities,
891
) {
884
- if (maintenanceCapabilities.latestVersion !== undefined) {
885
- return maintenanceCapabilities.latestVersion;
886
- }
887
- const packageName = maintenanceCapabilities.packageName;
888
- if (!packageName) {
889
- return null;
890
- }
891
-
892
const latestVersions = yield* ProviderLatestVersions.ProviderLatestVersions;
893
const installerKey = installerLatestVersionKey(maintenanceCapabilities);
894
if (installerKey && maintenanceCapabilities.lookupLatestVersion) {
@@ -898,9 +898,28 @@ export const resolveLatestProviderVersion = Effect.fn("resolveLatestProviderVers
898
);
899
if (installable !== null) return installable;
900
}
901
+ if (maintenanceCapabilities.latestVersion !== undefined) {
902
+ return maintenanceCapabilities.latestVersion;
903
+ }
904
+ const packageName = maintenanceCapabilities.packageName;
905
+ if (!packageName) {
906
+ return null;
907
+ }
908
+
909
return yield* latestVersions.cached(packageName, fetchNpmLatestVersion(packageName));
910
});
911
912
+export const invalidateLatestProviderVersion = Effect.fn("invalidateLatestProviderVersion")(
913
+ function* (maintenanceCapabilities: ProviderMaintenanceCapabilities) {
914
+ const latestVersions = yield* ProviderLatestVersions.ProviderLatestVersions;
915
+ yield* Effect.forEach(
916
+ latestProviderVersionCacheKeys(maintenanceCapabilities),
917
+ latestVersions.invalidate,
918
+ { discard: true },
919
+ );
920
+ },
921
+);
922
+
923
export const enrichProviderSnapshotWithVersionAdvisory = Effect.fn(
924
"enrichProviderSnapshotWithVersionAdvisory",
925
)(function* (
packages/provider-grok/src/server/driver.test.ts
+6
-2
@@ -15,6 +15,7 @@ import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderL
15
import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
16
import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
17
import { GrokDriver } from "./driver.ts";
18
+import { resolveLatestProviderVersion } from "@t3tools/provider-core/server/maintenanceResolver";
19
20
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
21
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
@@ -110,7 +111,7 @@ it.layer(layerTest)("GrokDriver", (it) => {
111
name: "upgrades a Homebrew grok-build cask through brew",
112
binary: ["Caskroom", "grok-build", "1.2.3,456", "grok"],
113
reportedPrefix: "own",
113
- brewArgs: [["--prefix"], ["info", "--json=v2", "grok-build"]],
114
+ brewArgs: [["--prefix"]],
115
latestVersion: "1.2.4",
116
update: (brewPath: string, _binaryPath: string) => ({
117
command: "brew upgrade --cask grok-build",
@@ -180,8 +181,11 @@ it.layer(layerTest)("GrokDriver", (it) => {
181
182
const update = testCase.update(brewPath, binaryPath);
183
expect(brewArgs).toEqual(testCase.brewArgs);
183
- expect(capabilities.latestVersion).toBe(testCase.latestVersion);
184
expect(capabilities.update).toEqual(update && expect.objectContaining(update));
185
+ if (testCase.latestVersion !== undefined) {
186
+ expect(yield* resolveLatestProviderVersion(capabilities)).toBe(testCase.latestVersion);
187
+ expect(brewArgs).toEqual([...testCase.brewArgs, ["info", "--json=v2", "grok-build"]]);
188
+ }
189
}).pipe(
190
Effect.provideService(
191
ChildProcessSpawner.ChildProcessSpawner,