@devries-cameron20 / t3code-1 / commits / b39f45696e
Fork 0

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,