@devries-cameron20 / t3code Mirror · read-only / commits / 6a61904f60
Fork 0

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): native Claude updates use the native release feed (#27958)

Nate Glasby committed Nov 3, 2026 at 03:32 UTC 6a61904f609b1ab3387668de35996e8657cd4103
5 files changed +535 -34
apps/server/src/provider/Drivers/ClaudeDriver.ts
+10 -34
@@ -42,13 +42,7 @@ import {
42 type ProviderInstance,
43 } from "@t3tools/provider-core/server/driver";
44 import { withInstanceIdentity } from "@t3tools/provider-core/server/instanceIdentity";
45 -import {
46 - enrichProviderSnapshotWithVersionAdvisory,
47 - makeCachedProviderMaintenanceResolution,
48 - makePackageManagedProviderMaintenanceResolver,
49 - normalizeCommandPath,
50 - resolveProviderMaintenanceCapabilitiesEffect,
51 -} from "@t3tools/provider-core/server/maintenanceResolver";
45 +import { enrichProviderSnapshotWithVersionAdvisory } from "@t3tools/provider-core/server/maintenanceResolver";
46 import {
47 haveProviderSnapshotSettingsChanged,
48 makeProviderSnapshotSettingsSource,
@@ -61,6 +55,7 @@ import {
55 resolveClaudeHomePath,
56 } from "./ClaudeHome.ts";
57 import * as HostProcess from "@t3tools/shared/HostProcess";
58 +import { makeClaudeMaintenanceResolution } from "./ClaudeMaintenance.ts";
59 const decodeClaudeSettings = Schema.decodeSync(ClaudeSettings);
60
61 const DRIVER_KIND = ProviderDriverKind.make("claudeAgent");
@@ -72,24 +67,6 @@ const withoutUsage = (capabilities: ClaudeCapabilitiesProbe): ClaudeCapabilities
67 return result;
68 };
69
75 -function isClaudeNativeCommandPath(commandPath: string): boolean {
76 - const normalized = normalizeCommandPath(commandPath);
77 - return (
78 - normalized.endsWith("/.local/bin/claude") ||
79 - normalized.endsWith("/.local/bin/claude.exe") ||
80 - normalized.includes("/.local/share/claude/")
81 - );
82 -}
83 -
84 -const UPDATE = makePackageManagedProviderMaintenanceResolver({
85 - provider: DRIVER_KIND,
86 - npmPackageName: "@anthropic-ai/claude-code",
87 - nativeUpdate: {
88 - args: ["update"],
89 - isCommandPath: isClaudeNativeCommandPath,
90 - },
91 -});
92 -
70 export type ClaudeDriverEnv =
71 | ClaudeAdapterV2DriverEnv
72 | ProviderHost.ProviderHost
@@ -144,15 +121,14 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv, Path.
121 enabled,
122 binaryPath: expandHomePath(config.binaryPath, yield* HostProcess.HomeDirectory),
123 } satisfies ClaudeSettings;
147 - const resolveMaintenance = yield* makeCachedProviderMaintenanceResolution(
148 - resolveProviderMaintenanceCapabilitiesEffect(UPDATE, {
149 - binaryPath: effectiveConfig.binaryPath,
150 - env: processEnv,
151 - }).pipe(
152 - Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
153 - Effect.provideService(FileSystem.FileSystem, fileSystem),
154 - Effect.provideService(Path.Path, path),
155 - ),
124 + const resolveMaintenance = yield* makeClaudeMaintenanceResolution({
125 + binaryPath: effectiveConfig.binaryPath,
126 + env: processEnv,
127 + }).pipe(
128 + Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
129 + Effect.provideService(FileSystem.FileSystem, fileSystem),
130 + Effect.provideService(Path.Path, path),
131 + Effect.provideService(HttpClient.HttpClient, httpClient),
132 );
133 const continuationGroupKey = yield* makeClaudeContinuationGroupKey(effectiveConfig, processEnv);
134 const configDir = yield* resolveClaudeHomePath(effectiveConfig, processEnv);
apps/server/src/provider/Drivers/ClaudeMaintenance.test.ts new
+406
@@ -0,0 +1,406 @@
1 +import * as NodeServices from "@effect/platform-node/NodeServices";
2 +import { expect, it } from "@effect/vitest";
3 +import {
4 + DEFAULT_SERVER_SETTINGS,
5 + ProviderDriverKind,
6 + ProviderInstanceId,
7 + type ServerProvider,
8 +} from "@t3tools/contracts";
9 +import * as HostProcess from "@t3tools/shared/HostProcess";
10 +import {
11 + enrichProviderSnapshotWithVersionAdvisory,
12 + invalidateLatestProviderVersion,
13 +} from "@t3tools/provider-core/server/maintenanceResolver";
14 +import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
15 +import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
16 +import { makeManagedServerProvider } from "@t3tools/provider-core/server/managedProvider";
17 +import * as Effect from "effect/Effect";
18 +import * as Fiber from "effect/Fiber";
19 +import * as FileSystem from "effect/FileSystem";
20 +import * as Layer from "effect/Layer";
21 +import * as Path from "effect/Path";
22 +import * as Queue from "effect/Queue";
23 +import * as Stream from "effect/Stream";
24 +import * as TestClock from "effect/testing/TestClock";
25 +import * as HttpClient from "effect/http/HttpClient";
26 +import * as HttpClientResponse from "effect/http/HttpClientResponse";
27 +import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
28 +import { makeClaudeMaintenanceResolution } from "./ClaudeMaintenance.ts";
29 +
30 +const snapshot: ServerProvider = {
31 + instanceId: ProviderInstanceId.make("claude"),
32 + driver: ProviderDriverKind.make("claudeAgent"),
33 + enabled: true,
34 + installed: true,
35 + version: "2.1.314",
36 + status: "ready",
37 + auth: { status: "authenticated" },
38 + checkedAt: "2026-10-31T00:00:00.000Z",
39 + models: [],
40 + slashCommands: [],
41 + skills: [],
42 +};
43 +
44 +const fixture = Effect.fn("ClaudeMaintenance.test.fixture")(function* (
45 + npm = false,
46 + platform: NodeJS.Platform = "linux",
47 + programFiles?: string,
48 +) {
49 + const fs = yield* FileSystem.FileSystem;
50 + const path = yield* Path.Path;
51 + const directory = yield* fs.makeTempDirectoryScoped();
52 + const binaryPath = npm
53 + ? path.join(directory, "lib/node_modules/@anthropic-ai/claude-code/cli.js")
54 + : path.join(directory, ".local/bin", platform === "win32" ? "claude.exe" : "claude");
55 + yield* fs.makeDirectory(path.dirname(binaryPath), { recursive: true });
56 + yield* fs.writeFileString(binaryPath, "#!/bin/sh\n");
57 + yield* fs.chmod(binaryPath, 0o755);
58 + const configDirectory = path.join(directory, "config");
59 + yield* fs.makeDirectory(configDirectory);
60 + const settingsPath = path.join(configDirectory, "settings.json");
61 + const managed = new Map<string, string>();
62 + const managedDirectory =
63 + platform === "win32"
64 + ? `${programFiles ?? "C:/Program Files"}/ClaudeCode`
65 + : platform === "darwin"
66 + ? "/Library/Application Support/ClaudeCode"
67 + : "/etc/claude-code";
68 + let installationReads = 0;
69 + const testFs = FileSystem.makeNoop({
70 + ...fs,
71 + realPath: (file) => {
72 + if (file === binaryPath) installationReads++;
73 + return fs.realPath(file);
74 + },
75 + readFileString: (file, ...args) =>
76 + file.replaceAll("\\", "/").startsWith(`${managedDirectory}/`)
77 + ? managed.has(file.replaceAll("\\", "/"))
78 + ? Effect.succeed(managed.get(file.replaceAll("\\", "/"))!)
79 + : fs.readFileString(path.join(directory, "missing"))
80 + : fs.readFileString(file, ...args),
81 + readDirectory: (file) =>
82 + file.replaceAll("\\", "/") === `${managedDirectory}/managed-settings.d`
83 + ? Effect.succeed(
84 + [...managed.keys()]
85 + .filter((key) => key.includes("/managed-settings.d/"))
86 + .map((key) => path.basename(key)),
87 + )
88 + : fs.readDirectory(file),
89 + });
90 + return {
91 + directory,
92 + fs,
93 + managed,
94 + managedDirectory,
95 + settingsPath,
96 + installationReads: () => installationReads,
97 + makeResolution: makeClaudeMaintenanceResolution({ binaryPath, env: { PATH: "" } }).pipe(
98 + Effect.provideService(
99 + ChildProcessSpawner.ChildProcessSpawner,
100 + ChildProcessSpawner.make(() => Effect.die("version checks must not run a subprocess")),
101 + ),
102 + Effect.provideService(FileSystem.FileSystem, testFs),
103 + Effect.provideService(HostProcess.Platform, platform),
104 + Effect.provideService(HostProcess.Environment, {
105 + PATH: "",
106 + CLAUDE_CONFIG_DIR: configDirectory,
107 + ...(programFiles ? { PROGRAMFILES: programFiles } : {}),
108 + }),
109 + ),
110 + };
111 +});
112 +
113 +it.layer(NodeServices.layer)("ClaudeMaintenance", (it) => {
114 + it.effect.each([
115 + {
116 + name: "default native channel",
117 + settings: undefined,
118 + channel: "latest",
119 + body: "2.1.314\n",
120 + status: 200,
121 + expected: "2.1.314",
122 + advisory: "current",
123 + npm: false,
124 + },
125 + {
126 + name: "explicit latest channel",
127 + settings: '{"autoUpdatesChannel":"latest"}',
128 + channel: "latest",
129 + body: "2.1.314",
130 + status: 200,
131 + expected: "2.1.314",
132 + advisory: "current",
133 + npm: false,
134 + },
135 + {
136 + name: "stable channel",
137 + settings: '{"autoUpdatesChannel":"stable"}',
138 + channel: "stable",
139 + body: "2.1.308",
140 + status: 200,
141 + expected: "2.1.308",
142 + advisory: "current",
143 + npm: false,
144 + },
145 + {
146 + name: "new native release",
147 + settings: undefined,
148 + channel: "latest",
149 + body: "2.1.315",
150 + status: 200,
151 + expected: "2.1.315",
152 + advisory: "behind_latest",
153 + npm: false,
154 + },
155 + {
156 + name: "unavailable feed",
157 + settings: undefined,
158 + channel: "latest",
159 + body: "Unavailable",
160 + status: 503,
161 + expected: null,
162 + advisory: "unknown",
163 + npm: false,
164 + },
165 + {
166 + name: "malformed feed",
167 + settings: undefined,
168 + channel: "latest",
169 + body: "<html>error</html>",
170 + status: 200,
171 + expected: null,
172 + advisory: "unknown",
173 + npm: false,
174 + },
175 + {
176 + name: "empty feed",
177 + settings: undefined,
178 + channel: "latest",
179 + body: " ",
180 + status: 200,
181 + expected: null,
182 + advisory: "unknown",
183 + npm: false,
184 + },
185 + {
186 + name: "npm install",
187 + settings: '{"autoUpdatesChannel":"stable"}',
188 + channel: "latest",
189 + body: "",
190 + status: 200,
191 + expected: "2.1.316",
192 + advisory: "behind_latest",
193 + npm: true,
194 + },
195 + ])("advertises the installable version for $name", (row) =>
196 + Effect.gen(function* () {
197 + const f = yield* fixture(row.npm);
198 + if (row.settings) yield* f.fs.writeFileString(f.settingsPath, row.settings);
199 + const requests: string[] = [];
200 + const client = HttpClient.make((request) => {
201 + requests.push(request.url);
202 + return Effect.succeed(
203 + HttpClientResponse.fromWeb(
204 + request,
205 + request.url.includes("claude-code-releases/")
206 + ? new Response(row.body, { status: row.status })
207 + : Response.json({ version: "2.1.316" }),
208 + ),
209 + );
210 + });
211 + const resolve = yield* f.makeResolution.pipe(
212 + Effect.provideService(HttpClient.HttpClient, client),
213 + );
214 + const maintenance = yield* resolve();
215 + const versions = yield* ProviderLatestVersions.make();
216 + const enrich = enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenance).pipe(
217 + Effect.provideService(HttpClient.HttpClient, client),
218 + Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, versions),
219 + );
220 + expect((yield* enrich).versionAdvisory).toMatchObject({
221 + status: row.advisory,
222 + latestVersion: row.expected,
223 + });
224 + expect(requests).toHaveLength(1);
225 + expect(requests[0]).toMatch(
226 + row.npm ? /registry\.npmjs\.org/ : new RegExp(`claude-code-releases/${row.channel}$`),
227 + );
228 + yield* enrich;
229 + expect(requests).toHaveLength(1);
230 + }).pipe(Effect.scoped),
231 + );
232 +
233 + it.effect.each([
234 + { name: "Linux", platform: "linux", programFiles: undefined },
235 + { name: "macOS", platform: "darwin", programFiles: undefined },
236 + { name: "Windows default path", platform: "win32", programFiles: undefined },
237 + { name: "Windows custom path", platform: "win32", programFiles: "D:/Programs" },
238 + ] as const)(
239 + "separates channel caches and honors $name managed overrides and feed invalidation",
240 + (row) =>
241 + Effect.gen(function* () {
242 + const f = yield* fixture(false, row.platform, row.programFiles);
243 + const requests: string[] = [];
244 + const client = HttpClient.make((request) => {
245 + requests.push(request.url);
246 + return Effect.succeed(
247 + HttpClientResponse.fromWeb(
248 + request,
249 + new Response(request.url.endsWith("/stable") ? "2.1.308" : "2.1.314"),
250 + ),
251 + );
252 + });
253 + const versions = yield* ProviderLatestVersions.make();
254 + const resolve = yield* f.makeResolution.pipe(
255 + Effect.provideService(HttpClient.HttpClient, client),
256 + );
257 + const check = Effect.gen(function* () {
258 + const capabilities = yield* resolve();
259 + return yield* enrichProviderSnapshotWithVersionAdvisory(snapshot, capabilities);
260 + }).pipe(
261 + Effect.provideService(HttpClient.HttpClient, client),
262 + Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, versions),
263 + );
264 + expect((yield* check).versionAdvisory?.latestVersion).toBe("2.1.314");
265 + yield* f.fs.writeFileString(f.settingsPath, '{"autoUpdatesChannel":"stable"}');
266 + expect((yield* check).versionAdvisory?.latestVersion).toBe("2.1.308");
267 + f.managed.set(
268 + `${f.managedDirectory}/managed-settings.json`,
269 + '{"autoUpdatesChannel":"latest"}',
270 + );
271 + expect((yield* check).versionAdvisory?.latestVersion).toBe("2.1.314");
272 + f.managed.set(
273 + `${f.managedDirectory}/managed-settings.d/20-channel.json`,
274 + '{"autoUpdatesChannel":"stable"}',
275 + );
276 + f.managed.set(
277 + `${f.managedDirectory}/managed-settings.d/10-channel.json`,
278 + '{"autoUpdatesChannel":"latest"}',
279 + );
280 + expect((yield* check).versionAdvisory?.latestVersion).toBe("2.1.308");
281 + expect(requests).toHaveLength(2);
282 + const capabilities = yield* resolve();
283 + yield* invalidateLatestProviderVersion(capabilities).pipe(
284 + Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, versions),
285 + );
286 + yield* check;
287 + expect(requests).toHaveLength(3);
288 + }).pipe(Effect.scoped),
289 + );
290 +
291 + it.effect("automatic refresh rereads the native channel while preserving both caches", () =>
292 + Effect.gen(function* () {
293 + const f = yield* fixture();
294 + const requests: string[] = [];
295 + const client = HttpClient.make((request) => {
296 + requests.push(request.url);
297 + return Effect.succeed(
298 + HttpClientResponse.fromWeb(
299 + request,
300 + new Response(request.url.endsWith("/stable") ? "2.1.308" : "2.1.315"),
301 + ),
302 + );
303 + });
304 + const resolveMaintenance = yield* f.makeResolution.pipe(
305 + Effect.provideService(HttpClient.HttpClient, client),
306 + );
307 + const versions = yield* ProviderLatestVersions.make();
308 + const publications = yield* Queue.unbounded<ServerProvider>();
309 + yield* makeManagedServerProvider({
310 + resolveMaintenance,
311 + getSettings: Effect.succeed({ enabled: true }),
312 + streamSettings: Stream.empty,
313 + haveSettingsChanged: () => false,
314 + initialSnapshot: () => Effect.succeed(snapshot),
315 + checkProvider: Effect.succeed(snapshot),
316 + refreshInterval: "1 minute",
317 + enrichSnapshot: ({ snapshot, publishSnapshot }) =>
318 + resolveMaintenance().pipe(
319 + Effect.flatMap((maintenance) =>
320 + enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenance),
321 + ),
322 + Effect.provideService(HttpClient.HttpClient, client),
323 + Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, versions),
324 + Effect.flatMap((enriched) =>
325 + publishSnapshot(enriched).pipe(
326 + Effect.andThen(Queue.offer(publications, enriched)),
327 + Effect.asVoid,
328 + ),
329 + ),
330 + ),
331 + }).pipe(
332 + Effect.provide(
333 + Layer.mock(ProviderHost.ProviderHost)({
334 + paths: {
335 + cwd: f.directory,
336 + baseDir: f.directory,
337 + stateDir: f.directory,
338 + providerStatusCacheDir: f.directory,
339 + attachmentsDir: f.directory,
340 + },
341 + settings: {
342 + get: Effect.succeed(DEFAULT_SERVER_SETTINGS),
343 + withSnapshot: (use) => use(DEFAULT_SERVER_SETTINGS),
344 + changes: Stream.empty,
345 + subscribe: Effect.succeed(Stream.empty),
346 + },
347 + shouldRunBackgroundWork: () => Effect.succeed(true),
348 + resolveAttachmentPath: () => null,
349 + }),
350 + ),
351 + );
352 + expect((yield* Queue.take(publications)).versionAdvisory).toMatchObject({
353 + latestVersion: "2.1.315",
354 + status: "behind_latest",
355 + });
356 + expect(requests).toHaveLength(1);
357 +
358 + for (const channel of ["stable", "stable", "latest"] as const) {
359 + yield* f.fs.writeFileString(
360 + f.settingsPath,
361 + JSON.stringify({ autoUpdatesChannel: channel }),
362 + );
363 + yield* TestClock.adjust("1 minute");
364 + expect((yield* Queue.take(publications)).versionAdvisory).toMatchObject({
365 + latestVersion: channel === "stable" ? "2.1.308" : "2.1.315",
366 + status: channel === "stable" ? "current" : "behind_latest",
367 + });
368 + expect(requests).toEqual([
369 + "https://downloads.claude.ai/claude-code-releases/latest",
370 + "https://downloads.claude.ai/claude-code-releases/stable",
371 + ]);
372 + expect(f.installationReads()).toBe(1);
373 + }
374 + }).pipe(Effect.scoped),
375 + );
376 +
377 + it.effect("bounds stalled feed bodies and skips disabled update checks", () =>
378 + Effect.gen(function* () {
379 + const f = yield* fixture();
380 + let requests = 0;
381 + const client = HttpClient.make((request) => {
382 + requests++;
383 + return Effect.succeed(
384 + HttpClientResponse.fromWeb(request, new Response(new ReadableStream())),
385 + );
386 + });
387 + const resolve = yield* f.makeResolution.pipe(
388 + Effect.provideService(HttpClient.HttpClient, client),
389 + );
390 + const capabilities = yield* resolve();
391 + const enrich = (enabled: boolean) =>
392 + enrichProviderSnapshotWithVersionAdvisory(snapshot, capabilities, {
393 + enableProviderUpdateChecks: enabled,
394 + }).pipe(
395 + Effect.provide(ProviderLatestVersions.layer),
396 + Effect.provideService(HttpClient.HttpClient, client),
397 + );
398 + expect((yield* enrich(false)).versionAdvisory?.status).toBe("unknown");
399 + expect(requests).toBe(0);
400 + const pending = yield* enrich(true).pipe(Effect.forkChild({ startImmediately: true }));
401 + yield* TestClock.adjust("4 seconds");
402 + expect((yield* Fiber.join(pending)).versionAdvisory?.status).toBe("unknown");
403 + expect(requests).toBe(1);
404 + }).pipe(Effect.scoped),
405 + );
406 +});
apps/server/src/provider/Drivers/ClaudeMaintenance.ts new
+116
@@ -0,0 +1,116 @@
1 +import { ProviderDriverKind } from "@t3tools/contracts";
2 +import {
3 + makeCachedProviderMaintenanceResolution,
4 + makePackageManagedProviderMaintenanceResolver,
5 + normalizeCommandPath,
6 + resolveProviderMaintenanceCapabilitiesEffect,
7 + type ProviderMaintenanceCapabilities,
8 + type ProviderMaintenanceResolverServices,
9 +} from "@t3tools/provider-core/server/maintenanceResolver";
10 +import * as HostProcess from "@t3tools/shared/HostProcess";
11 +import { fromLenientJson } from "@t3tools/shared/schemaJson";
12 +import * as Effect from "effect/Effect";
13 +import * as FileSystem from "effect/FileSystem";
14 +import * as Path from "effect/Path";
15 +import * as Option from "effect/Option";
16 +import * as Schema from "effect/Schema";
17 +import * as HttpClient from "effect/http/HttpClient";
18 +import * as HttpClientResponse from "effect/http/HttpClientResponse";
19 +import { resolveClaudeHomePath } from "./ClaudeHome.ts";
20 +
21 +const NATIVE_RELEASES = "https://downloads.claude.ai/claude-code-releases";
22 +const UpdateChannelSettings = fromLenientJson(
23 + Schema.Struct({ autoUpdatesChannel: Schema.optional(Schema.Literals(["latest", "stable"])) }),
24 +);
25 +const NativeVersion = Schema.String.check(Schema.isPattern(/^\d+\.\d+\.\d+$/));
26 +
27 +const update = makePackageManagedProviderMaintenanceResolver({
28 + provider: ProviderDriverKind.make("claudeAgent"),
29 + npmPackageName: "@anthropic-ai/claude-code",
30 + nativeUpdate: {
31 + args: ["update"],
32 + isCommandPath: (commandPath) => {
33 + const normalized = normalizeCommandPath(commandPath);
34 + return (
35 + normalized.endsWith("/.local/bin/claude") ||
36 + normalized.endsWith("/.local/bin/claude.exe") ||
37 + normalized.includes("/.local/share/claude/")
38 + );
39 + },
40 + },
41 +});
42 +
43 +const readUpdateChannel = Effect.fn("ClaudeMaintenance.readUpdateChannel")(function* () {
44 + const fs = yield* FileSystem.FileSystem;
45 + const path = yield* Path.Path;
46 + const environment = yield* HostProcess.Environment;
47 + const platform = yield* HostProcess.Platform;
48 + const managedDirectory =
49 + platform === "darwin"
50 + ? "/Library/Application Support/ClaudeCode"
51 + : platform === "win32"
52 + ? path.join(environment.PROGRAMFILES || "C:\\Program Files", "ClaudeCode")
53 + : "/etc/claude-code";
54 + const dropInDirectory = path.join(managedDirectory, "managed-settings.d");
55 + const dropIns = yield* fs.readDirectory(dropInDirectory).pipe(Effect.orElseSucceed(() => []));
56 + // The updater inherits the server's config directory, not the instance's homePath.
57 + const configDirectory = yield* resolveClaudeHomePath({ homePath: "" }, environment);
58 + const settingsPaths = [
59 + path.join(configDirectory, "settings.json"),
60 + path.join(managedDirectory, "managed-settings.json"),
61 + ...dropIns
62 + .filter((name) => name.endsWith(".json") && !name.startsWith("."))
63 + .toSorted()
64 + .map((name) => path.join(dropInDirectory, name)),
65 + ];
66 + const channels = yield* Effect.forEach(settingsPaths, (settingsPath) =>
67 + fs.readFileString(settingsPath).pipe(
68 + Effect.flatMap(Schema.decodeUnknownEffect(UpdateChannelSettings)),
69 + Effect.map((settings) => settings.autoUpdatesChannel),
70 + Effect.orElseSucceed(() => undefined),
71 + ),
72 + );
73 + return channels.findLast((channel) => channel !== undefined) ?? "latest";
74 +});
75 +
76 +const resolveClaudeMaintenance = Effect.fn("ClaudeMaintenance.resolve")(function* (
77 + capabilities: ProviderMaintenanceCapabilities,
78 +) {
79 + if (capabilities.update?.lockKey !== "claudeAgent-native") return capabilities;
80 + const channel = yield* readUpdateChannel();
81 + const client = yield* HttpClient.HttpClient;
82 + const url = `${NATIVE_RELEASES}/${channel}`;
83 + return {
84 + ...capabilities,
85 + latestVersion: null,
86 + latestVersionCacheKey: url,
87 + lookupLatestVersion: client.get(url).pipe(
88 + Effect.flatMap(HttpClientResponse.filterStatusOk),
89 + Effect.flatMap((response) => response.text),
90 + Effect.map((text) => text.trim()),
91 + Effect.flatMap(Schema.decodeUnknownEffect(NativeVersion)),
92 + Effect.timeoutOption("4 seconds"),
93 + Effect.map(Option.getOrNull),
94 + Effect.orElseSucceed(() => null),
95 + ),
96 + };
97 +});
98 +
99 +export const makeClaudeMaintenanceResolution = Effect.fn("ClaudeMaintenance.make")(function* (
100 + options: Parameters<typeof resolveProviderMaintenanceCapabilitiesEffect>[1],
101 +) {
102 + const services = yield* Effect.context<
103 + ProviderMaintenanceResolverServices | HttpClient.HttpClient
104 + >();
105 + const resolveInstallation = yield* makeCachedProviderMaintenanceResolution(
106 + resolveProviderMaintenanceCapabilitiesEffect(update, options).pipe(
107 + Effect.provideContext(services),
108 + ),
109 + );
110 + const resolve: typeof resolveInstallation = (refreshOptions) =>
111 + resolveInstallation(refreshOptions).pipe(
112 + Effect.flatMap(resolveClaudeMaintenance),
113 + Effect.provideContext(services),
114 + );
115 + return resolve;
116 +});
packages/provider-core/src/server/maintenance.ts
+2
@@ -12,6 +12,8 @@ export interface ProviderMaintenanceCapabilities {
12 * `latestVersion`, then npm.
13 */
14 readonly lookupLatestVersion?: Effect.Effect<string | null>;
15 + /** Separates installer release channels that share an update command. */
16 + readonly latestVersionCacheKey?: string;
17 readonly compareVersions?: (current: string, latest: string) => number;
18 /** Resolved executable path for advisories when no update command is proven. */
19 readonly installPath?: string;
packages/provider-core/src/server/maintenanceResolver.ts
+1
@@ -980,6 +980,7 @@ const fetchNpmLatestVersion = Effect.fn("fetchNpmLatestVersion")(function* (pack
980 */
981 function installerLatestVersionKey(capabilities: ProviderMaintenanceCapabilities) {
982 if (!capabilities.lookupLatestVersion) return null;
983 + if (capabilities.latestVersionCacheKey) return capabilities.latestVersionCacheKey;
984 const update = capabilities.update;
985 if (update) return [update.lockKey, update.executable, ...update.args].join("\0");
986 return capabilities.installPath