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