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 21, 06:00 UTC
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
+);