@devries-cameron20 / t3code-1 / commits / 2f577fa397
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

test(server): wait for the settings watcher before restoring the directory (#39056)

Co-authored-by: Julius Marminge <julius0216@outlook.com>

Wout Stiens committed Nov 19, 2026 at 11:25 UTC 2f577fa397340c591ec8c43cb55e717b5981ae0c
3 files changed +361 -31
apps/server/src/serverSettings.test.ts
+173
@@ -32,6 +32,7 @@ import * as Schema from "effect/Schema";
32 import * as Stream from "effect/Stream";
33 import * as SchemaAST from "effect/SchemaAST";
34 import * as SqlClient from "effect/sql/SqlClient";
35 +import * as TestClock from "effect/testing/TestClock";
36 import * as ServerSecretStore from "./auth/ServerSecretStore.ts";
37 import { sourceControlHostSecretName } from "./sourceControl/sourceControlHostSecrets.ts";
38 import * as ServerConfig from "./config.ts";
@@ -3121,3 +3122,175 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))(
3122 );
3123 },
3124 );
3125 +
3126 +it.live("reloads a symlinked settings file after its target directory is replaced", () =>
3127 + Effect.gen(function* () {
3128 + const config = yield* ServerConfig.ServerConfig;
3129 + const fs = yield* FileSystem.FileSystem;
3130 + const path = yield* Path.Path;
3131 + const service = yield* ServerSettingsModule.ServerSettingsService;
3132 + const dotfiles = yield* fs.makeTempDirectoryScoped({ prefix: "t3-settings-dotfiles-" });
3133 + const active = path.join(dotfiles, "active");
3134 + const restored = path.join(dotfiles, "restored");
3135 + yield* fs.makeDirectory(active);
3136 + yield* fs.makeDirectory(restored);
3137 + yield* fs.writeFileString(
3138 + path.join(active, "settings.json"),
3139 + `{ "responseStreamingMode": "turn" }`,
3140 + );
3141 + yield* fs.writeFileString(
3142 + path.join(restored, "settings.json"),
3143 + `{ "responseStreamingMode": "turn" }`,
3144 + );
3145 + yield* fs.remove(config.settingsPath, { force: true });
3146 + yield* fs.symlink(path.join(active, "settings.json"), config.settingsPath);
3147 + yield* service.start;
3148 + const changes = yield* service.subscribeChanges;
3149 +
3150 + yield* fs.writeFileString(
3151 + path.join(restored, "settings.json"),
3152 + `{ "responseStreamingMode": "turn", "defaultAutoPull": true }`,
3153 + );
3154 + yield* fs.rename(active, path.join(dotfiles, "previous"));
3155 + yield* fs.rename(restored, active);
3156 +
3157 + const restoredSettings = yield* changes.pipe(
3158 + Stream.filter((settings) => settings.defaultAutoPull),
3159 + Stream.runHead,
3160 + );
3161 + assert.isTrue(Option.isSome(restoredSettings));
3162 +
3163 + yield* fs.writeFileString(
3164 + path.join(active, "settings.json"),
3165 + `{ "responseStreamingMode": "paragraph" }`,
3166 + );
3167 +
3168 + const reloaded = yield* changes.pipe(
3169 + Stream.filter((settings) => settings.responseStreamingMode === "paragraph"),
3170 + Stream.runHead,
3171 + );
3172 + assert.isTrue(Option.isSome(reloaded));
3173 + }).pipe(
3174 + Effect.scoped,
3175 + // @effect-diagnostics-next-line multipleEffectProvide:off -- the settings layer reads the Node services provided below.
3176 + Effect.provide(layerServerSettings()),
3177 + Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
3178 + ),
3179 +);
3180 +
3181 +it.effect("starts with symlinked settings when the settings directory watch fails", () =>
3182 + Effect.gen(function* () {
3183 + const fs = yield* FileSystem.FileSystem;
3184 + const path = yield* Path.Path;
3185 + let settingsDirectory: string | undefined;
3186 + const watchFailure = PlatformError.systemError({
3187 + _tag: "Unknown",
3188 + module: "FileSystem",
3189 + method: "watch",
3190 + description: "No file watches available.",
3191 + });
3192 + const failingFileSystem = FileSystem.FileSystem.of({
3193 + ...fs,
3194 + watch: (directory, options) =>
3195 + directory === settingsDirectory ? Stream.fail(watchFailure) : fs.watch(directory, options),
3196 + });
3197 + const settingsLayer = layerServerSettings().pipe(
3198 + Layer.provide(Layer.succeed(FileSystem.FileSystem, failingFileSystem)),
3199 + );
3200 +
3201 + yield* Effect.gen(function* () {
3202 + const config = yield* ServerConfig.ServerConfig;
3203 + const service = yield* ServerSettingsModule.ServerSettingsService;
3204 + settingsDirectory = path.dirname(config.settingsPath);
3205 + const dotfiles = yield* fs.makeTempDirectoryScoped({ prefix: "t3-settings-dotfiles-" });
3206 + const target = path.join(dotfiles, "settings.json");
3207 + yield* fs.writeFileString(target, `{ "responseStreamingMode": "paragraph" }`);
3208 + yield* fs.remove(config.settingsPath, { force: true });
3209 + yield* fs.symlink(target, config.settingsPath);
3210 +
3211 + yield* service.start;
3212 +
3213 + const settings = yield* service.getSettings;
3214 + assert.equal(settings.responseStreamingMode, "paragraph");
3215 + }).pipe(Effect.provide(settingsLayer));
3216 + }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
3217 +);
3218 +
3219 +it.effect("publishes edits made before the restored settings watch is registered", () =>
3220 + Effect.gen(function* () {
3221 + const fs = yield* FileSystem.FileSystem;
3222 + const path = yield* Path.Path;
3223 + const dotfiles = yield* fs.makeTempDirectoryScoped({ prefix: "t3-settings-dotfiles-" });
3224 + const active = path.join(dotfiles, "active");
3225 + const restored = path.join(dotfiles, "restored");
3226 + const target = path.join(active, "settings.json");
3227 + yield* fs.makeDirectory(active);
3228 + yield* fs.makeDirectory(restored);
3229 + yield* fs.writeFileString(target, `{ "responseStreamingMode": "turn" }`);
3230 + yield* fs.writeFileString(
3231 + path.join(restored, "settings.json"),
3232 + `{ "responseStreamingMode": "turn" }`,
3233 + );
3234 +
3235 + const replaced = yield* Deferred.make<void>();
3236 + const registering = yield* Deferred.make<void>();
3237 + const allowRegistration = yield* Deferred.make<void>();
3238 + const settingsLayer = layerServerSettings().pipe(
3239 + Layer.provide(
3240 + Layer.succeed(
3241 + FileSystem.FileSystem,
3242 + FileSystem.FileSystem.of({
3243 + ...fs,
3244 + watch: (directory, options) =>
3245 + Stream.unwrap(
3246 + Effect.gen(function* () {
3247 + if (directory === dotfiles) {
3248 + options?.onReady?.();
3249 + return Stream.fromEffect(Deferred.await(replaced)).pipe(
3250 + Stream.as({ _tag: "Create", path: "active" } as const),
3251 + Stream.concat(Stream.never),
3252 + );
3253 + }
3254 + if (directory !== active) return fs.watch(directory, options);
3255 + if (yield* Deferred.isDone(replaced)) {
3256 + yield* Deferred.succeed(registering, undefined);
3257 + yield* Deferred.await(allowRegistration);
3258 + }
3259 + options?.onReady?.();
3260 + return Stream.never;
3261 + }),
3262 + ),
3263 + }),
3264 + ),
3265 + ),
3266 + );
3267 +
3268 + yield* Effect.gen(function* () {
3269 + const config = yield* ServerConfig.ServerConfig;
3270 + const service = yield* ServerSettingsModule.ServerSettingsService;
3271 + yield* fs.symlink(target, config.settingsPath);
3272 + yield* service.start;
3273 + const changes = yield* service.subscribeChanges;
3274 +
3275 + yield* fs.rename(active, path.join(dotfiles, "previous"));
3276 + yield* fs.rename(restored, active);
3277 + // Deliver the event on the test clock so it drains the watcher and any eager debounce.
3278 + yield* Deferred.succeed(replaced, undefined).pipe(
3279 + Effect.delay(1),
3280 + Effect.forkScoped({ startImmediately: true }),
3281 + );
3282 + yield* TestClock.adjust("1 second");
3283 + yield* Deferred.await(registering);
3284 + yield* service.withSettingsSnapshot(() => Effect.void);
3285 + yield* fs.writeFileString(target, `{ "responseStreamingMode": "paragraph" }`);
3286 + yield* Deferred.succeed(allowRegistration, undefined).pipe(
3287 + Effect.delay(1),
3288 + Effect.forkScoped({ startImmediately: true }),
3289 + );
3290 + yield* TestClock.adjust("1 second");
3291 +
3292 + const published = yield* changes.pipe(Stream.runHead);
3293 + assert.equal(Option.getOrThrow(published).responseStreamingMode, "paragraph");
3294 + }).pipe(Effect.provide(settingsLayer));
3295 + }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
3296 +);
apps/server/src/serverSettings.ts
+86 -31
@@ -1277,22 +1277,63 @@ const make = Effect.gen(function* () {
1277 }),
1278 );
1279
1280 - const watchFileChanges = (filePath: string) => {
1280 + // `ready` completes once the watch is registered, or once it fails to be.
1281 + const watchFileChanges = (filePath: string, ready: Deferred.Deferred<void>) => {
1282 const directory = pathService.dirname(filePath);
1283 const fileName = pathService.basename(filePath);
1284 const resolvedFilePath = pathService.resolve(filePath);
1284 - return fs
1285 - .watch(directory)
1286 - .pipe(
1287 - Stream.filter(
1288 - (event) =>
1289 - event.path === fileName ||
1290 - event.path === filePath ||
1291 - pathService.resolve(directory, event.path) === resolvedFilePath,
1292 - ),
1293 - );
1285 + const markReady = () => Deferred.doneUnsafe(ready, Exit.void);
1286 + return fs.watch(directory, { onReady: markReady }).pipe(
1287 + Stream.filter(
1288 + (event) =>
1289 + event.path === fileName ||
1290 + event.path === filePath ||
1291 + pathService.resolve(directory, event.path) === resolvedFilePath,
1292 + ),
1293 + Stream.as(undefined),
1294 + Stream.ensuring(Effect.sync(markReady)),
1295 + );
1296 };
1297
1298 + // A directory watch follows the directory's inode, so when the target's
1299 + // directory is renamed away and another takes its path, watch the new one.
1300 + const watchLinkTargetChanges = (linkTargetPath: string, ready: Deferred.Deferred<void>) =>
1301 + Stream.unwrap(
1302 + Effect.gen(function* () {
1303 + const parentReady = yield* Deferred.make<void>();
1304 + const replacements = yield* watchFileChanges(
1305 + pathService.dirname(linkTargetPath),
1306 + parentReady,
1307 + ).pipe(
1308 + // Native watch registration can throw, including when the OS runs out of watches.
1309 + Stream.ignoreCause({ log: true }),
1310 + Stream.toQueue({ capacity: 1, strategy: "sliding" }),
1311 + );
1312 + // Start buffering replacements before attaching to the target directory's inode.
1313 + yield* Deferred.await(parentReady);
1314 +
1315 + const targetChanges = Stream.unwrap(
1316 + Effect.gen(function* () {
1317 + const registered = yield* Deferred.make<void>();
1318 + return Stream.merge(
1319 + watchFileChanges(linkTargetPath, registered).pipe(Stream.ignoreCause({ log: true })),
1320 + // Startup reloads once ready. Later watches trigger their own reload.
1321 + Stream.fromEffect(
1322 + Deferred.await(registered).pipe(Effect.andThen(Deferred.succeed(ready, undefined))),
1323 + ).pipe(
1324 + Stream.filter((completedStartup) => !completedStartup),
1325 + Stream.as(undefined),
1326 + ),
1327 + );
1328 + }),
1329 + );
1330 + return Stream.make(targetChanges).pipe(
1331 + Stream.concat(Stream.fromQueue(replacements).pipe(Stream.as(targetChanges))),
1332 + Stream.switchMap((changes) => changes),
1333 + );
1334 + }),
1335 + );
1336 +
1337 const startWatcher = Effect.gen(function* () {
1338 const settingsDir = pathService.dirname(settingsPath);
1339
@@ -1324,30 +1365,44 @@ const make = Effect.gen(function* () {
1365 return Option.some(linkTargetPath);
1366 }).pipe(Effect.orElseSucceed(() => Option.none<string>()));
1367
1327 - const initialLinkTarget = yield* watchLinkTarget;
1328 - const linkTargetEvents = Stream.make(initialLinkTarget).pipe(
1329 - Stream.concat(watchFileChanges(settingsPath).pipe(Stream.mapEffect(() => watchLinkTarget))),
1330 - Stream.changes,
1331 - Stream.switchMap(
1332 - Option.match({
1333 - onNone: () => Stream.empty,
1334 - onSome: (linkTargetPath) =>
1335 - watchFileChanges(linkTargetPath).pipe(Stream.ignore({ log: true })),
1336 - }),
1337 - ),
1338 - );
1339 -
1340 - // Saves emit multiple events; fs.watch may fire before content is flushed.
1341 - const debouncedSettingsEvents = Stream.merge(
1342 - watchFileChanges(settingsPath),
1343 - linkTargetEvents,
1344 - ).pipe(Stream.debounce(Duration.millis(100)));
1368 + const settingsReady = yield* Deferred.make<void>();
1369 + const linkTargetReady = yield* Deferred.make<void>();
1370 + yield* Effect.gen(function* () {
1371 + const [settingsEvents, resolveEvents] = yield* watchFileChanges(
1372 + settingsPath,
1373 + settingsReady,
1374 + ).pipe(
1375 + Stream.ignoreCause({ log: true }),
1376 + Stream.broadcastN({ n: 2, capacity: 1, strategy: "sliding" }),
1377 + );
1378 + // Buffer settings path changes while resolving the first target.
1379 + const linkTargetEvents = Stream.fromEffect(
1380 + Deferred.await(settingsReady).pipe(Effect.andThen(watchLinkTarget)),
1381 + ).pipe(
1382 + Stream.concat(resolveEvents.pipe(Stream.mapEffect(() => watchLinkTarget))),
1383 + Stream.changes,
1384 + Stream.switchMap(
1385 + Option.match({
1386 + onNone: () =>
1387 + Stream.fromEffect(Deferred.succeed(linkTargetReady, undefined)).pipe(Stream.drain),
1388 + onSome: (linkTargetPath) => watchLinkTargetChanges(linkTargetPath, linkTargetReady),
1389 + }),
1390 + ),
1391 + );
1392
1346 - yield* Stream.runForEach(debouncedSettingsEvents, () => revalidateAndEmitSafely).pipe(
1393 + // Saves emit multiple events; fs.watch may fire before content is flushed.
1394 + yield* Stream.merge(settingsEvents, linkTargetEvents).pipe(
1395 + Stream.debounce(Duration.millis(100)),
1396 + Stream.runForEach(() => revalidateAndEmitSafely),
1397 + );
1398 + }).pipe(
1399 + Effect.scoped,
1400 Effect.ignoreCause({ log: true }),
1401 + Effect.ensuring(Deferred.succeed(linkTargetReady, undefined)),
1402 Effect.forkIn(watcherScope),
1349 - Effect.asVoid,
1403 );
1404 + // Edits made once `start` returns must reach a registered watch.
1405 + yield* Deferred.await(linkTargetReady);
1406 });
1407
1408 const start = Effect.gen(function* () {
scripts/scenarios/restored-settings-directory-stays-live.e2e.ts new
+102
@@ -0,0 +1,102 @@
1 +import { expect } from "e2e";
2 +import * as Effect from "effect/Effect";
3 +import * as FileSystem from "effect/FileSystem";
4 +import * as Schema from "effect/Schema";
5 +
6 +import { T3_HOME } from "../e2e.config.ts";
7 +import { runPromise, test, WEB } from "./t3.ts";
8 +
9 +const decodeSettings = Schema.decodeSync(
10 + Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown)),
11 +);
12 +
13 +test(
14 + "Maintenance reflects edits to a symlinked settings file after restoring its directory",
15 + WEB,
16 + async ({ t3, app, screen }) => {
17 + await t3.project("settings-restore");
18 + const settingsPath = `${T3_HOME}/userdata/settings.json`;
19 + const active = `${T3_HOME}/active-settings`;
20 + const previous = `${T3_HOME}/old-settings`;
21 + const restored = `${T3_HOME}/restored-settings`;
22 + const original = await runPromise(
23 + Effect.gen(function* () {
24 + const fs = yield* FileSystem.FileSystem;
25 + return yield* fs.readFileString(settingsPath);
26 + }),
27 + );
28 + const settings = decodeSettings(original);
29 + const contents = (days: number) =>
30 + JSON.stringify({
31 + ...settings,
32 + storageCleanup: { logsAfterDays: days },
33 + });
34 +
35 + await runPromise(
36 + Effect.gen(function* () {
37 + const fs = yield* FileSystem.FileSystem;
38 + yield* fs.makeDirectory(active);
39 + yield* fs.makeDirectory(restored);
40 + yield* fs.writeFileString(`${active}/settings.json`, contents(5));
41 + yield* fs.writeFileString(`${restored}/settings.json`, contents(7));
42 + yield* fs.symlink(`${active}/settings.json`, `${settingsPath}.link`);
43 + yield* fs.rename(`${settingsPath}.link`, settingsPath);
44 + }),
45 + );
46 + try {
47 + await t3.open("/settings/maintenance");
48 + const days = screen.getByLabel("Delete old rotated logs in days");
49 + await days.scrollIntoView();
50 + await expect(days).toHaveValue("5");
51 + await runPromise(
52 + Effect.flatMap(FileSystem.FileSystem, (fs) =>
53 + fs.writeFileString(`${active}/settings.json`, contents(7)),
54 + ),
55 + );
56 + await expect(days).toHaveValue("7");
57 +
58 + await runPromise(
59 + Effect.gen(function* () {
60 + const fs = yield* FileSystem.FileSystem;
61 + yield* fs.writeFileString(`${restored}/settings.json`, contents(8));
62 + yield* fs.rename(active, previous);
63 + yield* fs.rename(restored, active);
64 + }),
65 + );
66 + try {
67 + await expect(days).toHaveValue("8");
68 + } catch (error) {
69 + await app.screenshot("retention-after-settings-directory-restore");
70 + throw error;
71 + }
72 + await runPromise(
73 + Effect.gen(function* () {
74 + const fs = yield* FileSystem.FileSystem;
75 + yield* fs.writeFileString(`${active}/settings.json`, contents(9));
76 + }),
77 + );
78 + try {
79 + await expect(days).toHaveValue("9");
80 + await runPromise(
81 + Effect.flatMap(FileSystem.FileSystem, (fs) =>
82 + fs.writeFileString(`${active}/settings.json`, contents(11)),
83 + ),
84 + );
85 + await expect(days).toHaveValue("11");
86 + } finally {
87 + await app.screenshot("retention-after-settings-directory-restore");
88 + }
89 + } finally {
90 + await runPromise(
91 + Effect.gen(function* () {
92 + const fs = yield* FileSystem.FileSystem;
93 + yield* fs.writeFileString(`${settingsPath}.original`, original);
94 + yield* fs.rename(`${settingsPath}.original`, settingsPath);
95 + for (const directory of [active, previous, restored]) {
96 + yield* fs.remove(directory, { recursive: true, force: true });
97 + }
98 + }),
99 + );
100 + }
101 + },
102 +);