Skip to content

Commit 2ed38b8

Browse files
committed
fix(server): discover shell-added remotes after a turn
1 parent 61c3794 commit 2ed38b8

3 files changed

Lines changed: 256 additions & 2 deletions

File tree

‎apps/server/src/orchestration-v2/RunFinalizationQueue.test.ts‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,9 @@ import * as Layer from "effect/Layer";
55
import * as Option from "effect/Option";
66

77
import * as SqlitePersistence from "../persistence/Sqlite.ts";
8+
import * as ProjectEnrichment from "../project/ProjectEnrichmentService.ts";
9+
import * as ProjectService from "../project/ProjectService.ts";
10+
import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
811
import * as PullRequestService from "../pullRequest/PullRequestService.ts";
912
import * as ServerSettings from "../serverSettings.ts";
1013
import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
@@ -48,6 +51,9 @@ it.effect.each([
4851
Layer.provide(
4952
Layer.mergeAll(
5053
projections,
54+
Layer.mock(ProjectService.ProjectService)({}),
55+
Layer.mock(ProjectEnrichment.ProjectEnrichmentService)({}),
56+
Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({}),
5157
Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }),
5258
Layer.mock(PullRequestService.PullRequestService)({ refreshAfterTurn: () => Effect.void }),
5359
Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({

‎apps/server/src/orchestration-v2/RunFinalizationService.test.ts‎

Lines changed: 224 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,27 @@
1+
import * as NodeServices from "@effect/platform-node/NodeServices";
12
import { assert, it } from "@effect/vitest";
23
import {
34
CheckpointScopeId,
5+
ProjectId,
6+
SourceControlProviderKind,
47
RunId,
58
ThreadId,
69
type OrchestrationV2ThreadShell,
710
} from "@t3tools/contracts";
811
import * as Deferred from "effect/Deferred";
912
import * as Effect from "effect/Effect";
1013
import * as Fiber from "effect/Fiber";
14+
import * as FileSystem from "effect/FileSystem";
15+
import * as PubSub from "effect/PubSub";
1116
import * as Layer from "effect/Layer";
1217
import * as Option from "effect/Option";
1318
import * as TestClock from "effect/testing/TestClock";
1419

20+
import * as ProcessRunner from "../processRunner.ts";
21+
import * as ProjectEnrichment from "../project/ProjectEnrichmentService.ts";
22+
import * as ProjectFaviconResolver from "../project/ProjectFaviconResolver.ts";
23+
import * as ProjectService from "../project/ProjectService.ts";
24+
import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
1525
import * as PullRequestService from "../pullRequest/PullRequestService.ts";
1626
import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
1727
import * as WorkspaceEntries from "../workspace/WorkspaceEntries.ts";
@@ -103,6 +113,9 @@ it.effect.each(
103113
const layer = RunFinalization.layerObserver.pipe(
104114
Layer.provide(
105115
Layer.mergeAll(
116+
Layer.mock(ProjectService.ProjectService)({}),
117+
Layer.mock(ProjectEnrichment.ProjectEnrichmentService)({}),
118+
Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({}),
106119
Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }),
107120
Layer.mock(PullRequestService.PullRequestService)({
108121
refreshAfterTurn: () => Effect.void,
@@ -150,6 +163,9 @@ it.effect("returns from the post-turn refresh without waiting for the PR lookup"
150163
const layer = RunFinalization.layerObserver.pipe(
151164
Layer.provide(
152165
Layer.mergeAll(
166+
Layer.mock(ProjectService.ProjectService)({}),
167+
Layer.mock(ProjectEnrichment.ProjectEnrichmentService)({}),
168+
Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({}),
153169
Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }),
154170
Layer.mock(PullRequestService.PullRequestService)({
155171
refreshAfterTurn: () => Effect.void,
@@ -200,6 +216,9 @@ it.effect("replaces a still-running PR lookup when a newer turn finishes", () =>
200216
const layer = RunFinalization.layerObserver.pipe(
201217
Layer.provide(
202218
Layer.mergeAll(
219+
Layer.mock(ProjectService.ProjectService)({}),
220+
Layer.mock(ProjectEnrichment.ProjectEnrichmentService)({}),
221+
Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({}),
203222
Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }),
204223
Layer.mock(PullRequestService.PullRequestService)({
205224
refreshAfterTurn: () => Effect.void,
@@ -241,3 +260,208 @@ it.effect("replaces a still-running PR lookup when a newer turn finishes", () =>
241260
assert.strictEqual(lookups, 2);
242261
}).pipe(Effect.provide(layer));
243262
});
263+
264+
it.live(
265+
"publishes a shell-added remote after a default-branch turn without waiting for the identity TTL",
266+
() =>
267+
Effect.gen(function* () {
268+
const fs = yield* FileSystem.FileSystem;
269+
const runner = yield* ProcessRunner.ProcessRunner;
270+
const cwd = yield* fs.makeTempDirectoryScoped({ prefix: "t3-turn-remote-" });
271+
const git = (args: ReadonlyArray<string>) =>
272+
runner.run({ command: "git", args: ["-C", cwd, ...args] });
273+
yield* git(["init", "--initial-branch=main"]);
274+
const threadId = ThreadId.make("thread-publish-remote");
275+
const projectId = ProjectId.make("project-publish-remote");
276+
const runId = RunId.make("run-publish-remote");
277+
let hasRemote = false;
278+
const metadata = ProjectEnrichment.layer.pipe(
279+
Layer.provideMerge(RepositoryIdentityResolver.layer),
280+
Layer.provide(
281+
Layer.mock(ProjectFaviconResolver.ProjectFaviconResolver)({
282+
resolvePath: () => Effect.succeed(null),
283+
invalidate: () => Effect.void,
284+
}),
285+
),
286+
);
287+
const layer = RunFinalization.layerObserver.pipe(
288+
Layer.provideMerge(metadata),
289+
Layer.provide(
290+
Layer.mergeAll(
291+
Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }),
292+
Layer.mock(PullRequestService.PullRequestService)({
293+
refreshAfterTurn: () => Effect.void,
294+
}),
295+
Layer.unwrap(
296+
Effect.gen(function* () {
297+
const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService;
298+
return Layer.mock(ProjectService.ProjectService)({
299+
getById: () =>
300+
enrichment.peek(cwd).pipe(
301+
Effect.map((value) =>
302+
Option.some({
303+
id: projectId,
304+
title: "Published project",
305+
workspaceRoot: cwd,
306+
repositoryIdentity: value.repositoryIdentity,
307+
defaultModelSelection: null,
308+
scripts: [],
309+
createdAt: "2026-01-01T00:00:00.000Z",
310+
updatedAt: "2026-01-01T00:00:00.000Z",
311+
deletedAt: null,
312+
}),
313+
),
314+
),
315+
});
316+
}),
317+
).pipe(Layer.provide(metadata)),
318+
Layer.mock(ProjectionStore.ProjectionStoreV2)({
319+
getThreadShell: () =>
320+
Effect.succeed({
321+
id: threadId,
322+
projectId,
323+
branch: "main",
324+
activeRunId: null,
325+
} as OrchestrationV2ThreadShell),
326+
}),
327+
Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({
328+
refreshLocalStatus: () =>
329+
Effect.succeed({
330+
isRepo: true,
331+
hasPrimaryRemote: false,
332+
isDefaultRef: true,
333+
refName: "main",
334+
hasWorkingTreeChanges: false,
335+
workingTree: { files: [], insertions: 0, deletions: 0 },
336+
...(hasRemote
337+
? {
338+
sourceControlProvider: {
339+
kind: SourceControlProviderKind.make("github"),
340+
name: "GitHub",
341+
baseUrl: "https://github.com",
342+
},
343+
}
344+
: {}),
345+
}),
346+
}),
347+
),
348+
),
349+
);
350+
yield* Effect.gen(function* () {
351+
const observer = yield* RunFinalization.RunFinalizationObserver;
352+
const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService;
353+
const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
354+
const changes = yield* enrichment.subscribeChanges;
355+
yield* enrichment.request(cwd);
356+
assert.isNull((yield* PubSub.take(changes)).enrichment.repositoryIdentity);
357+
yield* observer.refresh({ cwd, threadId, runId });
358+
yield* git(["remote", "add", "origin", "https://github.com/t3tools/turn-remote.git"]);
359+
hasRemote = true;
360+
assert.isNull(yield* resolver.resolve(cwd));
361+
assert.isNull((yield* enrichment.peek(cwd)).repositoryIdentity);
362+
yield* observer.refresh({ cwd, threadId, runId });
363+
const refreshed = yield* PubSub.take(changes);
364+
assert.equal(refreshed.workspaceRoot, cwd);
365+
assert.equal(
366+
refreshed.enrichment.repositoryIdentity?.canonicalKey,
367+
"github.com/t3tools/turn-remote",
368+
);
369+
assert.equal(
370+
(yield* enrichment.peek(cwd)).repositoryIdentity?.locator.remoteUrl,
371+
"https://github.com/t3tools/turn-remote.git",
372+
);
373+
}).pipe(Effect.provide(layer));
374+
}).pipe(
375+
Effect.provide(ProcessRunner.layer.pipe(Layer.provideMerge(NodeServices.layer))),
376+
Effect.scoped,
377+
),
378+
);
379+
380+
it.effect("does not force a known identity when only the enrichment cache has expired", () =>
381+
Effect.gen(function* () {
382+
const threadId = ThreadId.make("thread-known-identity");
383+
const projectId = ProjectId.make("project-known-identity");
384+
const runId = RunId.make("run-known-identity");
385+
const checked = yield* Deferred.make<boolean>();
386+
let afterExpiry = false;
387+
const resolverLayer = Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, {
388+
resolve: (_cwd, options) =>
389+
Effect.gen(function* () {
390+
if (afterExpiry) yield* Deferred.succeed(checked, options?.refresh === true);
391+
return {
392+
canonicalKey: "github.com/t3tools/known",
393+
rootPath: "/repo",
394+
locator: {
395+
source: "git-remote" as const,
396+
remoteName: "origin",
397+
remoteUrl: "https://github.com/t3tools/known.git",
398+
},
399+
};
400+
}),
401+
});
402+
const metadata = ProjectEnrichment.layer.pipe(
403+
Layer.provideMerge(resolverLayer),
404+
Layer.provide(
405+
Layer.mock(ProjectFaviconResolver.ProjectFaviconResolver)({
406+
resolvePath: () => Effect.succeed(null),
407+
invalidate: () => Effect.void,
408+
}),
409+
),
410+
);
411+
const layer = RunFinalization.layerObserver.pipe(
412+
Layer.provideMerge(metadata),
413+
Layer.provide(
414+
Layer.mergeAll(
415+
Layer.mock(WorkspaceEntries.WorkspaceEntries)({ refresh: () => Effect.void }),
416+
Layer.mock(PullRequestService.PullRequestService)({
417+
refreshAfterTurn: () => Effect.void,
418+
}),
419+
Layer.mock(ProjectService.ProjectService)({
420+
getById: () =>
421+
Effect.succeedSome({
422+
id: projectId,
423+
title: "Known project",
424+
workspaceRoot: "/repo",
425+
repositoryIdentity: null,
426+
defaultModelSelection: null,
427+
scripts: [],
428+
createdAt: "2026-01-01T00:00:00.000Z",
429+
updatedAt: "2026-01-01T00:00:00.000Z",
430+
deletedAt: null,
431+
}),
432+
}),
433+
Layer.mock(ProjectionStore.ProjectionStoreV2)({
434+
getThreadShell: () =>
435+
Effect.succeed({ id: threadId, projectId } as OrchestrationV2ThreadShell),
436+
}),
437+
Layer.mock(VcsStatusBroadcaster.VcsStatusBroadcaster)({
438+
refreshLocalStatus: () =>
439+
Effect.succeed({
440+
isRepo: true,
441+
hasPrimaryRemote: true,
442+
isDefaultRef: true,
443+
refName: "main",
444+
hasWorkingTreeChanges: false,
445+
workingTree: { files: [], insertions: 0, deletions: 0 },
446+
sourceControlProvider: {
447+
kind: SourceControlProviderKind.make("github"),
448+
name: "GitHub",
449+
baseUrl: "https://github.com",
450+
},
451+
}),
452+
}),
453+
),
454+
),
455+
);
456+
yield* Effect.gen(function* () {
457+
const enrichment = yield* ProjectEnrichment.ProjectEnrichmentService;
458+
const observer = yield* RunFinalization.RunFinalizationObserver;
459+
assert.isNotNull(yield* enrichment.readRepositoryIdentity("/repo"));
460+
yield* TestClock.adjust("1 minute");
461+
assert.isNull((yield* enrichment.peek("/repo")).repositoryIdentity);
462+
afterExpiry = true;
463+
yield* observer.refresh({ cwd: "/repo", threadId, runId });
464+
assert.isFalse(yield* Deferred.await(checked));
465+
}).pipe(Effect.provide(layer));
466+
}),
467+
);

‎apps/server/src/orchestration-v2/RunFinalizationService.ts‎

Lines changed: 26 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,8 +3,12 @@ import * as Context from "effect/Context";
33
import * as Effect from "effect/Effect";
44
import * as FiberMap from "effect/FiberMap";
55
import * as Layer from "effect/Layer";
6+
import * as Option from "effect/Option";
67
import * as Schema from "effect/Schema";
78

9+
import * as ProjectEnrichmentService from "../project/ProjectEnrichmentService.ts";
10+
import * as ProjectService from "../project/ProjectService.ts";
11+
import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
812
import * as PullRequestService from "../pullRequest/PullRequestService.ts";
913
import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
1014
import * as WorkspaceEntries from "../workspace/WorkspaceEntries.ts";
@@ -98,6 +102,10 @@ export const layerObserver = Layer.effect(
98102
const projections = yield* ProjectionStore.ProjectionStoreV2;
99103
const pullRequests = yield* PullRequestService.PullRequestService;
100104
const pullRequestLookups = yield* FiberMap.make<string>();
105+
const projects = yield* ProjectService.ProjectService;
106+
const enrichment = yield* ProjectEnrichmentService.ProjectEnrichmentService;
107+
const identities = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
108+
const identityRefreshes = yield* FiberMap.make<ProjectId>();
101109
return {
102110
refreshAfterTurn: pullRequests.refreshAfterTurn,
103111
refresh: Effect.fn("RunFinalizationService.refresh")(
@@ -106,9 +114,25 @@ export const layerObserver = Layer.effect(
106114
[workspaceEntries.refresh(cwd), vcsStatus.refreshLocalStatus(cwd)],
107115
{ concurrency: "unbounded" },
108116
);
109-
if (local.refName === null || local.isDefaultRef) return;
117+
if (!local.sourceControlProvider && (local.refName === null || local.isDefaultRef))
118+
return;
110119
const thread = yield* projections.getThreadShell(threadId);
111-
if (!thread || thread.branch !== local.refName) return;
120+
if (!thread) return;
121+
if (local.sourceControlProvider) {
122+
const project = yield* projects.getById(thread.projectId);
123+
if (Option.isSome(project) && project.value.repositoryIdentity === null) {
124+
const root = project.value.workspaceRoot;
125+
yield* Effect.gen(function* () {
126+
if ((yield* identities.resolve(root)) !== null) return;
127+
// Local status saw a remote while the resolver still has a cached miss.
128+
yield* identities.resolve(root, { refresh: true });
129+
yield* enrichment.invalidate([root]);
130+
yield* enrichment.request(root);
131+
}).pipe(FiberMap.run(identityRefreshes, thread.projectId, { onlyIfMissing: true }));
132+
}
133+
}
134+
if (local.refName === null || local.isDefaultRef || thread.branch !== local.refName)
135+
return;
112136
if (thread.activeRunId !== null && thread.activeRunId !== runId) return;
113137
// The forge CLI can take minutes, so the next turn must not wait for it. A newer
114138
// turn's lookup replaces a running one instead of queueing behind the cwd's lock.

0 commit comments

Comments
 (0)