@devries-cameron20 / t3code Mirror · read-only / commits / 3cdc504cc9
Fork 0

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, 00:45 UTC

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),