The best way to control Claude Code, Codex and more from any computer or phone
fix(server): linked projects keep their repository identity while it refreshes (#32359)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Nov 10, 2026 at 09:33 UTC
3cdc504cc98a85e4e29491ed3e14b6e281d92bb5
2 files changed
+177
-3
apps/server/src/project/ProjectEnrichmentService.test.ts
+131
@@ -1,10 +1,13 @@
1
import { assert, it } from "@effect/vitest";
2
import type { RepositoryIdentity } from "@t3tools/contracts";
3
import * as Deferred from "effect/Deferred";
4
+import * as Duration from "effect/Duration";
5
import * as Effect from "effect/Effect";
6
+import * as Fiber from "effect/Fiber";
7
import * as Layer from "effect/Layer";
8
import * as PubSub from "effect/PubSub";
9
import * as Ref from "effect/Ref";
10
+import * as TestClock from "effect/testing/TestClock";
11
12
import * as ProjectEnrichment from "./ProjectEnrichmentService.ts";
13
import * as ProjectFaviconResolver from "./ProjectFaviconResolver.ts";
@@ -257,3 +260,131 @@ it.effect("deduplicates requests, bounds pending work, and reloads invalidated r
260
);
261
}),
262
);
263
+
264
+it.effect(
265
+ "keeps the last resolved repository identity after it expires and while it refreshes",
266
+ () =>
267
+ Effect.gen(function* () {
268
+ const refreshStarted = yield* Deferred.make<void>();
269
+ const releaseRefresh = yield* Deferred.make<void>();
270
+ const resolveCalls = yield* Ref.make(0);
271
+ const layerMetadata = Layer.merge(
272
+ Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
273
+ resolve: (workspaceRoot) =>
274
+ Effect.gen(function* () {
275
+ if ((yield* Ref.updateAndGet(resolveCalls, (count) => count + 1)) > 1) {
276
+ yield* Deferred.succeed(refreshStarted, undefined);
277
+ yield* Deferred.await(releaseRefresh);
278
+ }
279
+ return identity(workspaceRoot);
280
+ }),
281
+ }),
282
+ Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
283
+ invalidate: () => Effect.void,
284
+ resolvePath: () => Effect.succeed(null),
285
+ }),
286
+ );
287
+
288
+ yield* Effect.gen(function* () {
289
+ const service = yield* ProjectEnrichment.ProjectEnrichmentService;
290
+ const changes = yield* service.subscribeChanges;
291
+ yield* service.request("/widgets");
292
+ const resolved = yield* PubSub.take(changes);
293
+ assert.equal(
294
+ resolved.enrichment.repositoryIdentity?.canonicalKey,
295
+ "example.test/v1/widgets",
296
+ );
297
+
298
+ yield* TestClock.adjust(Duration.seconds(61));
299
+
300
+ const expired = yield* service.getAvailable("/widgets");
301
+ assert.equal(
302
+ expired.repositoryIdentity?.canonicalKey,
303
+ "example.test/v1/widgets",
304
+ "an expired repository identity should still be returned until a refresh replaces it",
305
+ );
306
+
307
+ yield* Deferred.await(refreshStarted);
308
+ const refreshing = yield* service.peek("/widgets");
309
+ assert.equal(
310
+ refreshing.repositoryIdentity?.canonicalKey,
311
+ "example.test/v1/widgets",
312
+ "a repository identity should still be returned while its refresh is pending",
313
+ );
314
+ }).pipe(Effect.provide(layer(layerMetadata)));
315
+ }),
316
+);
317
+
318
+it.effect("does not let a lookup invalidated mid-flight replace a newer last identity", () =>
319
+ Effect.gen(function* () {
320
+ const firstStarted = yield* Deferred.make<void>();
321
+ const releaseFirst = yield* Deferred.make<void>();
322
+ const resolveCalls = yield* Ref.make(0);
323
+ const layerMetadata = Layer.merge(
324
+ Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
325
+ resolve: (workspaceRoot) =>
326
+ Effect.gen(function* () {
327
+ const call = yield* Ref.updateAndGet(resolveCalls, (count) => count + 1);
328
+ if (call === 1) {
329
+ yield* Deferred.succeed(firstStarted, undefined);
330
+ yield* Deferred.await(releaseFirst);
331
+ }
332
+ return identity(workspaceRoot, call);
333
+ }),
334
+ }),
335
+ Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
336
+ invalidate: () => Effect.void,
337
+ resolvePath: () => Effect.succeed(null),
338
+ }),
339
+ );
340
+
341
+ yield* Effect.gen(function* () {
342
+ const service = yield* ProjectEnrichment.ProjectEnrichmentService;
343
+ const firstLookup = yield* Effect.forkChild(service.readRepositoryIdentity("/widgets"));
344
+ yield* Deferred.await(firstStarted);
345
+ yield* service.invalidate(["/widgets"]);
346
+ const newer = yield* service.readRepositoryIdentity("/widgets");
347
+ assert.equal(newer?.canonicalKey, "example.test/v2/widgets");
348
+
349
+ yield* Deferred.succeed(releaseFirst, undefined);
350
+ yield* Fiber.join(firstLookup);
351
+ yield* TestClock.adjust(Duration.seconds(61));
352
+
353
+ const expired = yield* service.peek("/widgets");
354
+ assert.equal(expired.repositoryIdentity?.canonicalKey, "example.test/v2/widgets");
355
+ }).pipe(Effect.provide(layer(layerMetadata)));
356
+ }),
357
+);
358
+
359
+it.effect("keeps a lookup's identity when another root is invalidated mid-flight", () =>
360
+ Effect.gen(function* () {
361
+ const started = yield* Deferred.make<void>();
362
+ const release = yield* Deferred.make<void>();
363
+ const layerMetadata = Layer.merge(
364
+ Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
365
+ resolve: (workspaceRoot) =>
366
+ Deferred.succeed(started, undefined).pipe(
367
+ Effect.andThen(Deferred.await(release)),
368
+ Effect.as(identity(workspaceRoot)),
369
+ ),
370
+ }),
371
+ Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
372
+ invalidate: () => Effect.void,
373
+ resolvePath: () => Effect.succeed(null),
374
+ }),
375
+ );
376
+
377
+ yield* Effect.gen(function* () {
378
+ const service = yield* ProjectEnrichment.ProjectEnrichmentService;
379
+ const lookup = yield* Effect.forkChild(service.readRepositoryIdentity("/widgets"));
380
+ yield* Deferred.await(started);
381
+ yield* service.invalidate(["/other"]);
382
+ yield* Deferred.succeed(release, undefined);
383
+ yield* Fiber.join(lookup);
384
+ yield* TestClock.adjust(Duration.seconds(61));
385
+
386
+ const expired = yield* service.peek("/widgets");
387
+ assert.equal(expired.repositoryIdentity?.canonicalKey, "example.test/v1/widgets");
388
+ }).pipe(Effect.provide(layer(layerMetadata)));
389
+ }),
390
+);
apps/server/src/project/ProjectEnrichmentService.ts
+46
-3
@@ -91,8 +91,44 @@ export const make = Effect.fn("ProjectEnrichmentService.make")(function* (
91
const maxPending = Math.max(1, options.maxPending ?? DEFAULT_MAX_PENDING);
92
const concurrency = Math.max(1, options.concurrency ?? DEFAULT_CONCURRENCY);
93
94
+ // Outlives the cache entry so an expired or refreshing identity still reads as its last value.
95
+ const lastRepositoryIdentities = new Map<string, RepositoryIdentity>();
96
+ // `invalidate` drops a root's in-flight lookup so its late result cannot overwrite a newer one.
97
+ const lookupsInFlight = new Map<string, object>();
98
+ const rememberRepositoryIdentity = (
99
+ workspaceRoot: string,
100
+ repositoryIdentity: RepositoryIdentity | null,
101
+ ) => {
102
+ lastRepositoryIdentities.delete(workspaceRoot);
103
+ if (repositoryIdentity === null) return;
104
+ if (lastRepositoryIdentities.size >= cacheCapacity) {
105
+ const oldestRoot = lastRepositoryIdentities.keys().next().value;
106
+ if (oldestRoot !== undefined) lastRepositoryIdentities.delete(oldestRoot);
107
+ }
108
+ lastRepositoryIdentities.set(workspaceRoot, repositoryIdentity);
109
+ };
110
+
111
const repositoryIdentityCache = yield* Cache.makeWith(
95
- (workspaceRoot: string) => Effect.exit(repositoryIdentityResolver.resolve(workspaceRoot)),
112
+ (workspaceRoot: string) =>
113
+ Effect.suspend(() => {
114
+ const lookup = {};
115
+ lookupsInFlight.set(workspaceRoot, lookup);
116
+ const isCurrent = () => lookupsInFlight.get(workspaceRoot) === lookup;
117
+ return Effect.exit(repositoryIdentityResolver.resolve(workspaceRoot)).pipe(
118
+ Effect.tap((result) =>
119
+ Effect.sync(() => {
120
+ if (Exit.isSuccess(result) && isCurrent()) {
121
+ rememberRepositoryIdentity(workspaceRoot, result.value);
122
+ }
123
+ }),
124
+ ),
125
+ Effect.ensuring(
126
+ Effect.sync(() => {
127
+ if (isCurrent()) lookupsInFlight.delete(workspaceRoot);
128
+ }),
129
+ ),
130
+ );
131
+ }),
132
{
133
capacity: cacheCapacity,
134
timeToLive: Exit.match({
@@ -238,10 +274,13 @@ export const make = Effect.fn("ProjectEnrichmentService.make")(function* (
274
] as const,
275
{ concurrency: "unbounded" },
276
);
277
+ const repositoryIdentityResolved = isSuccessfullyResolved(repositoryIdentity);
278
return {
242
- repositoryIdentity: availableValue(repositoryIdentity),
279
+ repositoryIdentity: repositoryIdentityResolved
280
+ ? availableValue(repositoryIdentity)
281
+ : (lastRepositoryIdentities.get(workspaceRoot) ?? null),
282
faviconPath: availableValue(faviconPath),
244
- repositoryIdentityResolved: isSuccessfullyResolved(repositoryIdentity),
283
+ repositoryIdentityResolved,
284
};
285
},
286
);
@@ -287,6 +326,10 @@ export const make = Effect.fn("ProjectEnrichmentService.make")(function* (
326
Effect.all(
327
[
328
Cache.invalidate(repositoryIdentityCache, workspaceRoot),
329
+ Effect.sync(() => {
330
+ lookupsInFlight.delete(workspaceRoot);
331
+ lastRepositoryIdentities.delete(workspaceRoot);
332
+ }),
333
Cache.invalidate(faviconCache, workspaceRoot),
334
// The resolver keeps its own misses, which would outlive a clone filling the folder.
335
faviconResolver.invalidate(workspaceRoot),