Skip to content

Commit da17a0e

Browse files
fix(server): Claude's update channel follows a refresh and managed drop-ins
The channel is now read each time maintenance capabilities resolve, so a manual refresh after switching channels picks it up. Only the stable channel attaches an installer lookup; every other channel uses the npm `latest` path exactly as before, so the two answers never share a cache entry. Managed `managed-settings.d/*.json` drop-ins are merged after the base file in name order, last value wins. `hasClaudeManagedMcpConfig` is back to main's code. Co-Authored-By: Claude Opus 5.5 <[email protected]>
1 parent c9d663c commit da17a0e

3 files changed

Lines changed: 143 additions & 47 deletions

File tree

‎apps/server/src/provider/Drivers/ClaudeDriver.test.ts‎

Lines changed: 82 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -98,10 +98,11 @@ const noSpawn = ChildProcessSpawner.make(() =>
9898
Effect.die("Version advisory resolution must not spawn a process"),
9999
);
100100

101-
// A native launcher at 2.1.308 with the given user and managed settings.json contents.
102-
const resolveNativeAdvisory = Effect.fn("resolveNativeAdvisory")(function* (input: {
101+
// A native launcher at 2.1.308 with the given user, managed and managed drop-in settings.
102+
const makeNativeInstall = Effect.fn("makeNativeInstall")(function* (input: {
103103
readonly user: object;
104104
readonly managed?: object;
105+
readonly managedDropIns?: Record<string, object>;
105106
readonly unavailableTags?: ReadonlyArray<string>;
106107
}) {
107108
const fs = yield* FileSystem.FileSystem;
@@ -111,23 +112,30 @@ const resolveNativeAdvisory = Effect.fn("resolveNativeAdvisory")(function* (inpu
111112
const versionPath = NodePath.join(home, ".local", "share", "claude", "versions", "2.1.308");
112113
const launcherPath = NodePath.join(home, ".local", "bin", "claude");
113114
const managedDirectory = NodePath.join(home, "managed");
115+
const writeUserSettings = (settings: object) =>
116+
fs.writeFileString(NodePath.join(home, ".claude", "settings.json"), JSON.stringify(settings));
114117
yield* fs.makeDirectory(NodePath.dirname(versionPath), { recursive: true });
115118
yield* fs.writeFileString(versionPath, "#!/bin/sh\n");
116119
yield* fs.chmod(versionPath, 0o755);
117120
yield* fs.makeDirectory(NodePath.dirname(launcherPath), { recursive: true });
118121
yield* fs.symlink(versionPath, launcherPath);
119122
yield* fs.makeDirectory(NodePath.join(home, ".claude"));
120-
yield* fs.writeFileString(
121-
NodePath.join(home, ".claude", "settings.json"),
122-
JSON.stringify(input.user),
123-
);
124-
yield* fs.makeDirectory(managedDirectory);
123+
yield* writeUserSettings(input.user);
124+
yield* fs.makeDirectory(NodePath.join(managedDirectory, "managed-settings.d"), {
125+
recursive: true,
126+
});
125127
if (input.managed) {
126128
yield* fs.writeFileString(
127129
NodePath.join(managedDirectory, "managed-settings.json"),
128130
JSON.stringify(input.managed),
129131
);
130132
}
133+
for (const [name, settings] of Object.entries(input.managedDropIns ?? {})) {
134+
yield* fs.writeFileString(
135+
NodePath.join(managedDirectory, "managed-settings.d", name),
136+
JSON.stringify(settings),
137+
);
138+
}
131139
const requestedTags: Array<string> = [];
132140

133141
const instance = yield* ClaudeDriver.create({
@@ -139,30 +147,38 @@ const resolveNativeAdvisory = Effect.fn("resolveNativeAdvisory")(function* (inpu
139147
}).pipe(
140148
Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, noSpawn),
141149
Effect.provideService(HostProcess.HomeDirectory, home),
150+
Effect.provideService(HostProcess.Environment, { HOME: home }),
142151
Effect.provideService(ClaudeManagedConfigDirectory, managedDirectory),
143152
Effect.provideService(
144153
HttpClient.HttpClient,
145154
makeNpmRegistry(requestedTags, input.unavailableTags),
146155
),
147156
);
148-
const capabilities = yield* instance.snapshot.resolveMaintenance();
149-
const latestVersion = yield* resolveLatestProviderVersion(capabilities).pipe(
150-
Effect.provideServiceEffect(
151-
ProviderLatestVersions.ProviderLatestVersions,
152-
ProviderLatestVersions.make(),
153-
),
154-
);
157+
const latestVersions = yield* ProviderLatestVersions.make();
155158

156-
expect(capabilities.update).toMatchObject({ executable: launcherPath, args: ["update"] });
157-
return {
158-
requestedTags,
159-
advisory: createProviderVersionAdvisory({
159+
const resolveAdvisory = Effect.fn("resolveAdvisory")(function* (options?: {
160+
readonly fresh?: boolean;
161+
}) {
162+
const capabilities = yield* instance.snapshot.resolveMaintenance(options);
163+
const latestVersion = yield* resolveLatestProviderVersion(capabilities).pipe(
164+
Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, latestVersions),
165+
);
166+
expect(capabilities.update).toMatchObject({ executable: launcherPath, args: ["update"] });
167+
return createProviderVersionAdvisory({
160168
driver: ClaudeDriver.driverKind,
161169
currentVersion: "2.1.308",
162170
latestVersion,
163171
maintenanceCapabilities: capabilities,
164-
}),
165-
};
172+
});
173+
});
174+
return { requestedTags, writeUserSettings, resolveAdvisory };
175+
});
176+
177+
const resolveNativeAdvisory = Effect.fn("resolveNativeAdvisory")(function* (
178+
input: Parameters<typeof makeNativeInstall>[0],
179+
) {
180+
const install = yield* makeNativeInstall(input);
181+
return { requestedTags: install.requestedTags, advisory: yield* install.resolveAdvisory() };
166182
});
167183

168184
it.layer(layerTest)("ClaudeDriver", (it) => {
@@ -212,6 +228,52 @@ it.layer(layerTest)("ClaudeDriver", (it) => {
212228
{ skip: windowsHost },
213229
);
214230

231+
it.effect(
232+
"follows the last managed drop-in's update channel over the base managed file",
233+
() =>
234+
Effect.gen(function* () {
235+
const { advisory } = yield* resolveNativeAdvisory({
236+
user: {},
237+
managed: { autoUpdatesChannel: "stable" },
238+
managedDropIns: {
239+
"10-telemetry.json": { env: {} },
240+
"20-updates.json": { autoUpdatesChannel: "latest" },
241+
"30-notes.txt": { autoUpdatesChannel: "stable" },
242+
},
243+
});
244+
expect(advisory).toMatchObject({
245+
status: "behind_latest",
246+
latestVersion: "2.1.312",
247+
});
248+
}).pipe(Effect.scoped),
249+
{ skip: windowsHost },
250+
);
251+
252+
it.effect(
253+
"follows a switched update channel after a fresh maintenance resolution",
254+
() =>
255+
Effect.gen(function* () {
256+
const install = yield* makeNativeInstall({ user: { autoUpdatesChannel: "stable" } });
257+
expect(yield* install.resolveAdvisory()).toMatchObject({
258+
status: "current",
259+
latestVersion: "2.1.308",
260+
});
261+
262+
yield* install.writeUserSettings({ autoUpdatesChannel: "latest" });
263+
expect(yield* install.resolveAdvisory({ fresh: true })).toMatchObject({
264+
status: "behind_latest",
265+
latestVersion: "2.1.312",
266+
});
267+
268+
yield* install.writeUserSettings({ autoUpdatesChannel: "stable" });
269+
expect(yield* install.resolveAdvisory({ fresh: true })).toMatchObject({
270+
status: "current",
271+
latestVersion: "2.1.308",
272+
});
273+
}).pipe(Effect.scoped),
274+
{ skip: windowsHost },
275+
);
276+
215277
it.effect(
216278
"reports no latest version when the stable channel's release cannot be fetched",
217279
() =>

‎apps/server/src/provider/Drivers/ClaudeDriver.ts‎

Lines changed: 53 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,7 @@ import {
4949
makeCachedProviderMaintenanceResolution,
5050
makePackageManagedProviderMaintenanceResolver,
5151
normalizeCommandPath,
52+
type ProviderMaintenanceCapabilitiesResolver,
5253
resolveProviderMaintenanceCapabilitiesEffect,
5354
} from "@t3tools/provider-core/server/maintenanceResolver";
5455
import {
@@ -57,7 +58,7 @@ import {
5758
type ProviderSnapshotSettings,
5859
} from "@t3tools/provider-core/server/snapshotSettings";
5960
import {
60-
claudeManagedConfigPath,
61+
ClaudeManagedConfigDirectory,
6162
makeClaudeCapabilitiesCacheKey,
6263
makeClaudeContinuationGroupKey,
6364
resolveClaudeHomePath,
@@ -85,6 +86,17 @@ function isClaudeNativeCommandPath(commandPath: string): boolean {
8586

8687
const CLAUDE_NPM_PACKAGE = "@anthropic-ai/claude-code";
8788

89+
const CLAUDE_NATIVE_UPDATE = {
90+
args: ["update"],
91+
isCommandPath: isClaudeNativeCommandPath,
92+
};
93+
94+
const UPDATE = makePackageManagedProviderMaintenanceResolver({
95+
provider: DRIVER_KIND,
96+
npmPackageName: CLAUDE_NPM_PACKAGE,
97+
nativeUpdate: CLAUDE_NATIVE_UPDATE,
98+
});
99+
88100
const ClaudeUpdateChannelSettings = Schema.fromJsonString(
89101
Schema.Struct({ autoUpdatesChannel: Schema.optional(Schema.String) }),
90102
);
@@ -144,38 +156,58 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv, Path.
144156
binaryPath: expandHomePath(config.binaryPath, yield* HostProcess.HomeDirectory),
145157
} satisfies ClaudeSettings;
146158
// The updater runs with the server's env, not this instance's, so it reads the server's config dir.
147-
const updateSettingsPaths = [
148-
yield* claudeManagedConfigPath("managed-settings.json"),
149-
path.join(
150-
yield* resolveClaudeHomePath({ homePath: "" }, yield* HostProcess.Environment),
151-
"settings.json",
152-
),
153-
];
159+
const userSettingsPath = path.join(
160+
yield* resolveClaudeHomePath({ homePath: "" }, yield* HostProcess.Environment),
161+
"settings.json",
162+
);
163+
const managedDirectory = yield* ClaudeManagedConfigDirectory;
164+
const managedDropInDirectory = path.join(managedDirectory, "managed-settings.d");
154165
const readUpdateChannel = (settingsPath: string) =>
155166
fileSystem.readFileString(settingsPath).pipe(
156167
Effect.flatMap(Schema.decodeUnknownEffect(ClaudeUpdateChannelSettings)),
157168
Effect.map((settings) => settings.autoUpdatesChannel),
158169
Effect.orElseSucceed(() => undefined),
159170
);
160-
// `claude update` installs the `stable` dist-tag when managed, else user, settings opt in.
161-
const lookupLatestVersion = Effect.forEach(updateSettingsPaths, readUpdateChannel).pipe(
162-
Effect.flatMap((channels) =>
163-
fetchNpmLatestVersion(
164-
CLAUDE_NPM_PACKAGE,
165-
channels.find((channel) => channel !== undefined) === "stable" ? "stable" : "latest",
166-
),
167-
),
168-
Effect.provideService(HttpClient.HttpClient, httpClient),
171+
// Drop-ins merge after managed-settings.json in name order; later values win.
172+
const managedSettingsPaths = fileSystem.readDirectory(managedDropInDirectory).pipe(
173+
Effect.orElseSucceed((): ReadonlyArray<string> => []),
174+
Effect.map((names) => [
175+
path.join(managedDirectory, "managed-settings.json"),
176+
...names
177+
.filter((name) => name.endsWith(".json") && !name.startsWith("."))
178+
.toSorted()
179+
.map((name) => path.join(managedDropInDirectory, name)),
180+
]),
181+
);
182+
// `claude update` follows `autoUpdatesChannel` from managed, else user, settings.
183+
const updateChannel = managedSettingsPaths.pipe(
184+
Effect.flatMap((paths) => Effect.forEach(paths, readUpdateChannel)),
185+
Effect.flatMap((channels) => {
186+
const managed = channels.findLast((channel) => channel !== undefined);
187+
return managed === undefined
188+
? readUpdateChannel(userSettingsPath)
189+
: Effect.succeed(managed);
190+
}),
169191
);
170-
const update = makePackageManagedProviderMaintenanceResolver({
192+
const stableUpdate = makePackageManagedProviderMaintenanceResolver({
171193
provider: DRIVER_KIND,
172194
npmPackageName: CLAUDE_NPM_PACKAGE,
173195
nativeUpdate: {
174-
args: ["update"],
175-
isCommandPath: isClaudeNativeCommandPath,
176-
lookupLatestVersion,
196+
...CLAUDE_NATIVE_UPDATE,
197+
lookupLatestVersion: fetchNpmLatestVersion(CLAUDE_NPM_PACKAGE, "stable").pipe(
198+
Effect.provideService(HttpClient.HttpClient, httpClient),
199+
),
177200
},
178201
});
202+
// Read per resolution so a refresh follows a channel switch.
203+
const update: ProviderMaintenanceCapabilitiesResolver = {
204+
resolve: (context) =>
205+
updateChannel.pipe(
206+
Effect.flatMap((channel) =>
207+
(channel === "stable" ? stableUpdate : UPDATE).resolve(context),
208+
),
209+
),
210+
};
179211
const resolveMaintenance = yield* makeCachedProviderMaintenanceResolution(
180212
resolveProviderMaintenanceCapabilitiesEffect(update, {
181213
binaryPath: effectiveConfig.binaryPath,

‎apps/server/src/provider/Drivers/ClaudeHome.ts‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,7 @@ export const makeClaudeEnvironment = Effect.fn("makeClaudeEnvironment")(function
4343
};
4444
});
4545

46-
/** Where administrators install Claude Code's managed-*.json files, which override user config. */
46+
/** Where administrators install Claude Code's managed settings, which override user settings. */
4747
export const ClaudeManagedConfigDirectory = Context.Reference<string>(
4848
"server/provider/Drivers/ClaudeManagedConfigDirectory",
4949
{
@@ -58,14 +58,16 @@ export const ClaudeManagedConfigDirectory = Context.Reference<string>(
5858
},
5959
);
6060

61-
// Windows accepts `/` after a `\\`-separated directory.
62-
export const claudeManagedConfigPath = (fileName: string) =>
63-
Effect.map(ClaudeManagedConfigDirectory, (directory) => `${directory}/${fileName}`);
64-
6561
/** managed-mcp.json excludes other MCP config and forbids --strict-mcp-config; omit the flag when present. */
6662
export const hasClaudeManagedMcpConfig = Effect.fn("hasClaudeManagedMcpConfig")(function* () {
6763
const fileSystem = yield* FileSystem.FileSystem;
68-
const managedMcpConfigPath = yield* claudeManagedConfigPath("managed-mcp.json");
64+
const platform = yield* HostProcess.Platform;
65+
const managedMcpConfigPath =
66+
platform === "darwin"
67+
? "/Library/Application Support/ClaudeCode/managed-mcp.json"
68+
: platform === "win32"
69+
? "C:\\Program Files\\ClaudeCode\\managed-mcp.json"
70+
: "/etc/claude-code/managed-mcp.json";
6971
return yield* fileSystem.exists(managedMcpConfigPath).pipe(Effect.orElseSucceed(() => false));
7072
});
7173

0 commit comments

Comments
 (0)