Skip to content

Commit b39f456

Browse files
fix(server): Homebrew installs no longer run brew info with update checks off (pingdotgg#19581)
Co-authored-by: Julius Marminge <[email protected]>
1 parent ce2815d commit b39f456

7 files changed

Lines changed: 237 additions & 40 deletions

File tree

‎apps/server/src/provider/providerMaintenanceRunner.test.ts‎

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1082,6 +1082,73 @@ it.effect.each([
10821082
},
10831083
);
10841084

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+
10851152
it.effect("refuses incompatible latest versions and unapproved or unpinnable targets", () => {
10861153
const calls: string[] = [];
10871154
const manifest: ModelManifest.ModelManifestData = {

‎apps/server/src/provider/providerMaintenanceRunner.ts‎

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,7 @@ import * as ProviderRegistry from "./ProviderRegistry.ts";
3030
import { makeProviderMaintenanceCommandCoordinator } from "./providerMaintenanceCommandCoordinator.ts";
3131
import {
3232
enrichProviderSnapshotWithVersionAdvisory,
33+
invalidateLatestProviderVersion,
3334
makeTargetedProviderUpdateAction,
3435
resolveLatestProviderUpdateAction,
3536
resolveLatestProviderVersion,
@@ -428,9 +429,11 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
428429
}
429430

430431
const manifest = yield* manifestService.current;
432+
// Check compatibility against what an unpinned command would install now.
431433
const candidateVersion =
432434
targetVersion ??
433-
(yield* resolveLatestProviderVersion(fresh).pipe(
435+
(yield* invalidateLatestProviderVersion(fresh).pipe(
436+
Effect.andThen(resolveLatestProviderVersion(fresh)),
434437
Effect.provideService(HttpClient.HttpClient, httpClient),
435438
Effect.provideService(
436439
ProviderLatestVersions.ProviderLatestVersions,
@@ -483,12 +486,14 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
483486
}
484487

485488
yield* setRunningMessage("Verifying the installed version");
486-
// Homebrew's "latest" moves once the upgrade lands; read it again.
487489
const verified = yield* providerRegistry.getProviderMaintenanceCapabilitiesForInstance(
488490
instanceId,
489491
provider,
490492
{ fresh: true },
491493
);
494+
yield* invalidateLatestProviderVersion(verified).pipe(
495+
Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, latestVersions),
496+
);
492497
const { verifiedProviders } = yield* verifyRefreshedProvider(
493498
provider,
494499
verified,

‎packages/provider-core/src/server/ProviderLatestVersions.ts‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,10 +38,15 @@ export const make = Effect.fn("ProviderLatestVersions.make")(function* (
3838
const now = DateTime.toEpochMillis(yield* DateTime.now);
3939
const existing = (yield* Ref.get(entries)).get(key);
4040
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));
4144
const version = yield* lookup;
4245
const ttl = version === null ? MISSING_TTL : FOUND_TTL;
4346
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,
4550
);
4651
return version;
4752
}),

‎packages/provider-core/src/server/maintenance.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,8 @@ export interface ProviderMaintenanceCapabilities {
1212
*/
1313
readonly latestVersion?: string | null;
1414
/**
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.
1617
*/
1718
readonly lookupLatestVersion?: Effect.Effect<string | null>;
1819
readonly compareVersions?: (current: string, latest: string) => number;

‎packages/provider-core/src/server/maintenanceResolver.test.ts‎

Lines changed: 114 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@ import {
2121
makeTargetedProviderUpdateAction,
2222
enrichProviderSnapshotWithVersionAdvisory,
2323
homebrewOwnershipFromCommandPath,
24+
invalidateLatestProviderVersion,
2425
makeCachedProviderMaintenanceResolution,
2526
makePackageManagedProviderMaintenanceResolver,
2627
makeProviderMaintenanceCapabilities,
@@ -1064,14 +1065,9 @@ it.layer(NodeServices.layer)("providerMaintenance", (it) => {
10641065
),
10651066
);
10661067

1067-
expect(spawned).toEqual([
1068-
[brewPath, "--prefix"],
1069-
[brewPath, "info", "--json=v2", fixture.name],
1070-
]);
1071-
expect(capabilities).toEqual({
1068+
expect(capabilities).toMatchObject({
10721069
provider: driver("packageTool"),
10731070
packageName: "@example/package-tool",
1074-
latestVersion: fixture.latestVersion,
10751071
update: {
10761072
command:
10771073
fixture.kind === "cask"
@@ -1086,29 +1082,129 @@ it.layer(NodeServices.layer)("providerMaintenance", (it) => {
10861082
},
10871083
});
10881084

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+
),
10981097
),
1099-
),
1100-
);
1098+
);
11011099

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({
11031107
status: fixture.latestVersion === null ? "unknown" : "current",
11041108
latestVersion: fixture.latestVersion,
11051109
canUpdate: true,
11061110
message: null,
11071111
});
1112+
expect(spawned).toEqual([
1113+
[brewPath, "--prefix"],
1114+
[brewPath, "info", "--json=v2", fixture.name],
1115+
]);
11081116
}),
11091117
{ skip: !symlinksSupported },
11101118
);
11111119

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+
11121208
it.effect.skipIf(windowsHost)(
11131209
"stays manual-only when the keg is not under the resolved brew's prefix",
11141210
() =>

‎packages/provider-core/src/server/maintenanceResolver.ts‎

Lines changed: 35 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -589,8 +589,8 @@ export const resolvePackageManagedProviderMaintenance = Effect.fn(
589589

590590
/**
591591
* `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.
594594
*/
595595
export const resolveHomebrewProviderMaintenance = Effect.fn("resolveHomebrewProviderMaintenance")(
596596
function* (
@@ -621,17 +621,24 @@ export const resolveHomebrewProviderMaintenance = Effect.fn("resolveHomebrewProv
621621
}
622622
const args =
623623
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>();
627625
return makeProviderMaintenanceCapabilities({
628626
provider: input.provider,
629627
packageName: input.packageName,
630628
updateExecutable: brewPath,
631629
updateArgs: args,
632630
updateLockKey: "homebrew",
633631
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+
),
635642
});
636643
},
637644
);
@@ -865,8 +872,9 @@ const fetchNpmLatestVersion = Effect.fn("fetchNpmLatestVersion")(function* (pack
865872

866873
/** The installer's own answer is cached apart from the npm registry entry. */
867874
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")
870878
: null;
871879
}
872880

@@ -881,14 +889,6 @@ export function latestProviderVersionCacheKeys(
881889
export const resolveLatestProviderVersion = Effect.fn("resolveLatestProviderVersion")(function* (
882890
maintenanceCapabilities: ProviderMaintenanceCapabilities,
883891
) {
884-
if (maintenanceCapabilities.latestVersion !== undefined) {
885-
return maintenanceCapabilities.latestVersion;
886-
}
887-
const packageName = maintenanceCapabilities.packageName;
888-
if (!packageName) {
889-
return null;
890-
}
891-
892892
const latestVersions = yield* ProviderLatestVersions.ProviderLatestVersions;
893893
const installerKey = installerLatestVersionKey(maintenanceCapabilities);
894894
if (installerKey && maintenanceCapabilities.lookupLatestVersion) {
@@ -898,9 +898,28 @@ export const resolveLatestProviderVersion = Effect.fn("resolveLatestProviderVers
898898
);
899899
if (installable !== null) return installable;
900900
}
901+
if (maintenanceCapabilities.latestVersion !== undefined) {
902+
return maintenanceCapabilities.latestVersion;
903+
}
904+
const packageName = maintenanceCapabilities.packageName;
905+
if (!packageName) {
906+
return null;
907+
}
908+
901909
return yield* latestVersions.cached(packageName, fetchNpmLatestVersion(packageName));
902910
});
903911

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+
904923
export const enrichProviderSnapshotWithVersionAdvisory = Effect.fn(
905924
"enrichProviderSnapshotWithVersionAdvisory",
906925
)(function* (

0 commit comments

Comments
 (0)