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

main
ts 5,416 lines 189 KB
Raw
1 import { SourceControlProviderKind } from "@t3tools/contracts";
2 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
3 import * as NodeServices from "@effect/platform-node/NodeServices";
4 import * as KeyValueStore from "effect/persistence/KeyValueStore";
5 import { assert, expect, it } from "@effect/vitest";
6 import * as Cause from "effect/Cause";
7 import * as Deferred from "effect/Deferred";
8 import * as Effect from "effect/Effect";
9 import * as Exit from "effect/Exit";
10 import * as Fiber from "effect/Fiber";
11 import * as Layer from "effect/Layer";
12 import * as Option from "effect/Option";
13 import * as Stream from "effect/Stream";
14 import * as TestClock from "effect/testing/TestClock";
15 import type {
16 OrchestrationProjectShell,
17 ProjectId,
18 PullRequestReviewCapabilities,
19 PullRequestReviewerCapabilities,
20 } from "@t3tools/contracts";
21 import { DEFAULT_SERVER_SETTINGS } from "@t3tools/contracts/settings";
22 import type { ServerSettings } from "@t3tools/contracts";
23 import * as ServerSettingsService from "../serverSettings.ts";
24 import { PullRequestOperationError } from "@t3tools/contracts";
25
26 import * as ProjectService from "../project/ProjectService.ts";
27 import * as SqlitePersistence from "../persistence/Sqlite.ts";
28 import * as PullRequestFilesViewed from "../persistence/PullRequestFilesViewed.ts";
29 import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
30 import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
31 import type { SourceControlProvider } from "@t3tools/source-control-core/server/SourceControlProvider";
32 import { isSshRemoteUrl } from "@t3tools/shared/sourceControl";
33 import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
34 import { fakePullRequestProvider } from "@t3tools/source-control-testing/fakeSourceControlDriver";
35 import {
36 PullRequestProviderError,
37 type ProviderChangeRequest,
38 type PullRequestProviderApi,
39 } from "@t3tools/source-control-core/server/PullRequestProvider";
40 import * as PullRequestProviderRegistry from "./PullRequestProviderRegistry.ts";
41 import * as PullRequestService from "./PullRequestService.ts";
42 import * as PullRequestReadCache from "./PullRequestReadCache.ts";
43
44 function project(input: {
45 readonly id: string;
46 readonly title: string;
47 readonly workspaceRoot: string;
48 readonly repository?: string;
49 readonly provider?: string;
50 readonly host?: string;
51 readonly remoteUrl?: string;
52 }): OrchestrationProjectShell {
53 const host = input.host ?? (input.provider === "gitlab" ? "gitlab.com" : "github.com");
54 return {
55 id: input.id as ProjectId,
56 title: input.title,
57 workspaceRoot: input.workspaceRoot,
58 ...(input.repository
59 ? {
60 repositoryIdentity: {
61 canonicalKey: `${host}/${input.repository}`,
62 locator: {
63 source: "git-remote" as const,
64 remoteName: "origin",
65 remoteUrl: input.remoteUrl ?? `https://${host}/${input.repository}.git`,
66 },
67 provider: SourceControlProviderKind.make(input.provider ?? "github"),
68 displayName: input.repository,
69 },
70 }
71 : {}),
72 defaultModelSelection: null,
73 scripts: [],
74 createdAt: "2026-07-01T00:00:00Z",
75 updatedAt: "2026-07-01T00:00:00Z",
76 };
77 }
78
79 function changeRequest(number: number, updatedAt: string): ProviderChangeRequest {
80 return {
81 number,
82 title: `Change request ${number}`,
83 url: `https://host/pull/${number}`,
84 author: { login: "octocat", name: null, avatarUrl: null },
85 headBranch: `feat/${number}`,
86 baseBranch: "main",
87 state: "open",
88 isDraft: false,
89 mergeability: "mergeable",
90 additions: 1,
91 deletions: 0,
92 createdAt: "2026-07-01T00:00:00Z",
93 updatedAt,
94 reviewRequestLogins: [],
95 labels: [],
96 };
97 }
98
99 function hostedChangeRequest(body: string, additions = 1) {
100 return {
101 ...changeRequest(1, "2026-07-02T00:00:00Z"),
102 body,
103 additions,
104 changedFiles: 2,
105 mergedAt: null,
106 closedAt: null,
107 reviewers: [],
108 checks: [],
109 mergeCapabilities: { merge: true, squash: true, rebase: true },
110 viewerPermissions: {
111 actions: ["merge"] as const,
112 comment: true,
113 resolve: true,
114 verdicts: ["comment", "approve", "request-changes"] as const,
115 requestReviewers: true,
116 },
117 };
118 }
119
120 it.effect("reads maintainer edits and changes them through the update command", () =>
121 Effect.gen(function* () {
122 let enabled = true;
123 const provider = fakePullRequestProvider(SourceControlProviderKind.make("github"), {
124 getChangeRequest: () =>
125 Effect.succeed({ ...hostedChangeRequest("Body"), maintainerCanModify: enabled }),
126 updateChangeRequest: (input) =>
127 Effect.sync(() => {
128 assert.strictEqual(input.title, undefined);
129 assert.strictEqual(input.body, undefined);
130 enabled = input.maintainerCanModify!;
131 }),
132 });
133 const service = yield* makeService({
134 projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
135 providers: [
136 {
137 ...provider,
138 capabilities: {
139 ...provider.capabilities,
140 edit: { changeRequest: true, comment: true, maintainerEdits: true },
141 },
142 },
143 ],
144 });
145 const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
146 assert.strictEqual((yield* service.detail(ref)).maintainerCanModify, true);
147 yield* service.update({ ...ref, maintainerCanModify: false });
148 assert.strictEqual((yield* service.detail(ref)).maintainerCanModify, false);
149 }),
150 );
151
152 it.effect("refuses maintainer edits on a host without the capability", () =>
153 Effect.gen(function* () {
154 let writes = 0;
155 const service = yield* makeService({
156 projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
157 providers: [
158 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
159 updateChangeRequest: () =>
160 Effect.sync(() => {
161 writes += 1;
162 }),
163 }),
164 ],
165 });
166 const result = yield* service
167 .update({
168 projectId: "p1" as ProjectId,
169 repository: "acme/web",
170 number: 1,
171 maintainerCanModify: false,
172 })
173 .pipe(Effect.flip);
174 assert.strictEqual(result._tag, "PullRequestOperationError");
175 assert.strictEqual(writes, 0);
176 }),
177 );
178
179 it.effect("does not wait for an in-flight detail read to display a preview", () =>
180 Effect.gen(function* () {
181 const detailStarted = yield* Deferred.make<void>();
182 const releaseDetail = yield* Deferred.make<void>();
183 const service = yield* makeService({
184 projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
185 providers: [
186 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
187 getChangeRequest: () =>
188 Deferred.succeed(detailStarted, undefined).pipe(
189 Effect.andThen(Deferred.await(releaseDetail)),
190 Effect.as(hostedChangeRequest("Description")),
191 ),
192 getChangeRequestPreview: () => Effect.succeed(changeRequest(1, "2026-07-02T00:00:00Z")),
193 }),
194 ],
195 });
196 const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
197 const detail = yield* Effect.forkChild(service.detail(ref));
198 yield* Deferred.await(detailStarted);
199 assert.strictEqual((yield* service.preview(ref)).title, "Change request 1");
200 yield* Deferred.succeed(releaseDetail, undefined);
201 yield* Fiber.join(detail);
202 }),
203 );
204
205 it.effect("shows a listed pull request's preview without asking the host again", () =>
206 Effect.gen(function* () {
207 let previewReads = 0;
208 const service = yield* makeService({
209 projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
210 providers: [
211 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
212 listChangeRequests: () =>
213 Effect.succeed({
214 items: [changeRequest(1, "2026-07-02T00:00:00Z")],
215 truncated: false,
216 continues: false,
217 }),
218 getChangeRequestPreview: () =>
219 Effect.sync(() => {
220 previewReads++;
221 return { ...changeRequest(1, "2026-07-02T00:00:00Z"), title: "Renamed" };
222 }),
223 }),
224 ],
225 });
226 const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
227 yield* service.list({ state: "open" });
228 assert.strictEqual((yield* service.preview(ref)).title, "Change request 1");
229 assert.strictEqual(previewReads, 0);
230 yield* service.refreshAfterTurn(ref.projectId);
231 assert.strictEqual((yield* service.preview(ref)).title, "Renamed");
232 assert.strictEqual(previewReads, 1);
233 yield* service.list({ state: "open", limit: 1 });
234 assert.strictEqual((yield* service.preview(ref)).title, "Renamed");
235 }),
236 );
237
238 it.effect("a list read under a pinned account leaves the shared preview to the host", () =>
239 Effect.gen(function* () {
240 let previewReads = 0;
241 const service = yield* makeService({
242 projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
243 providers: [
244 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
245 getRoutingIdentity: () => Effect.succeed({ accountId: "101", viewer: "octocat" }),
246 withVerifiedCredential: (_, use) =>
247 use({ accountId: "101", viewer: "octocat", credentialFingerprint: "pinned" }),
248 listChangeRequests: () =>
249 Effect.succeed({
250 items: [{ ...changeRequest(1, "2026-07-02T00:00:00Z"), title: "Pinned view" }],
251 truncated: false,
252 continues: false,
253 }),
254 getChangeRequestPreview: () =>
255 Effect.sync(() => {
256 previewReads++;
257 return changeRequest(1, "2026-07-02T00:00:00Z");
258 }),
259 }),
260 ],
261 });
262 const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
263 yield* service.withRoutingCredential(
264 { ...ref, host: "github.com", expectedAccountId: "101" },
265 service.list({ state: "open" }),
266 );
267 assert.strictEqual((yield* service.preview(ref)).title, "Change request 1");
268 assert.strictEqual(previewReads, 1);
269 }),
270 );
271
272 function unusable(provider: SourceControlProviderKind, reason: "missing-tool" | "unauthenticated") {
273 return new PullRequestProviderError({
274 provider,
275 operation: "getViewer",
276 reason,
277 detail: `${provider} is not usable.`,
278 });
279 }
280
281 const requestFailed = new PullRequestProviderError({
282 provider: SourceControlProviderKind.make("github"),
283 operation: "listChangeRequests",
284 reason: "failed",
285 detail: "HTTP 404",
286 });
287
288 const FULL_REVIEW: PullRequestReviewCapabilities = {
289 inlineComment: true,
290 reply: true,
291 resolve: true,
292 verdicts: ["comment", "approve", "request-changes"],
293 };
294
295 const FULL_REVIEWERS: PullRequestReviewerCapabilities = { request: true, listCandidates: true };
296
297 // Like Azure DevOps, whose repository names repeat across organizations and projects.
298 const keyedByCanonicalKey = {
299 repositoryKey: ({ canonicalKey }: { readonly canonicalKey: string }) => canonicalKey,
300 };
301
302 /** A host whose SSH remotes name an alias, so discovery says which server serves them. */
303 const sshAliasHost = {
304 resolveRemoteWebHost: ({ cwd, context, resolveContext }) =>
305 isSshRemoteUrl(context.remoteUrl)
306 ? resolveContext({
307 cwd,
308 context: {
309 ...context,
310 provider: { kind: SourceControlProviderKind.make("unknown"), name: "", baseUrl: "" },
311 },
312 }).pipe(
313 Effect.map((resolved) =>
314 resolved === null || resolved.provider.kind === "unknown"
315 ? null
316 : new URL(resolved.provider.baseUrl).host,
317 ),
318 )
319 : Effect.succeed(null),
320 } as SourceControlProvider["Service"];
321
322 function makeService(input: {
323 readonly settings?: ServerSettings;
324 readonly projects: ReadonlyArray<OrchestrationProjectShell>;
325 readonly providers: ReadonlyArray<PullRequestProviderApi>;
326 readonly resolveHandle?: SourceControlProviderRegistry.SourceControlProviderRegistry["Service"]["resolveHandle"];
327 readonly resolveRepositoryIdentity?: RepositoryIdentityResolver.RepositoryIdentityResolver["Service"]["resolve"];
328 readonly onProjectRead?: () => void;
329 }) {
330 // Build in the test scope; per-call Effect.provide would close the marks database on service acquisition.
331 return Effect.flatMap(
332 Layer.build(
333 Layer.mergeAll(
334 Layer.mock(ServerSettingsService.ServerSettingsService)({
335 getSettings: Effect.succeed(input.settings ?? DEFAULT_SERVER_SETTINGS),
336 }),
337 Layer.succeed(
338 PullRequestProviderRegistry.PullRequestProviderRegistry,
339 PullRequestProviderRegistry.fromProviders(input.providers),
340 ),
341 Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
342 resolveLink: () => undefined,
343 resolveHandle:
344 input.resolveHandle ?? (() => Effect.die("Unexpected provider refinement")),
345 get: (kind) =>
346 Effect.succeed(
347 kind === "forgejo" ? sshAliasHost : ({} as SourceControlProvider["Service"]),
348 ),
349 }),
350 Layer.mock(ProjectService.ProjectService)({
351 listShells: (options) =>
352 Effect.sync(() => {
353 input.onProjectRead?.();
354 return input.projects.filter(
355 (project) => options?.projectIds?.includes(project.id) ?? true,
356 );
357 }),
358 getShell: (projectId) =>
359 Effect.sync(() => {
360 input.onProjectRead?.();
361 return Option.fromNullishOr(input.projects.find((p) => p.id === projectId));
362 }),
363 }),
364 Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({
365 resolve: input.resolveRepositoryIdentity ?? (() => Effect.succeed(null)),
366 }),
367 SourceControlRateLimit.layer,
368 PullRequestFilesViewed.layer.pipe(Layer.provide(SqlitePersistence.layerMemory)),
369 Layer.effect(PullRequestReadCache.PullRequestReadCache, PullRequestReadCache.make).pipe(
370 Layer.provide(KeyValueStore.layerMemory),
371 Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
372 ),
373 ),
374 ),
375 (context) => Effect.provideContext(PullRequestService.make, context),
376 );
377 }
378
379 it.effect("lists GitHub Enterprise PRs for a stored unknown repository after host discovery", () =>
380 Effect.gen(function* () {
381 const service = yield* makeService({
382 projects: [
383 project({
384 id: "p1",
385 title: "enterprise",
386 workspaceRoot: "/repo",
387 repository: "team/project",
388 provider: SourceControlProviderKind.make("unknown"),
389 host: "code.example.test",
390 }),
391 ],
392 providers: [
393 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
394 listChangeRequests: ({ host, repository }) => {
395 assert.strictEqual(host, "code.example.test");
396 assert.strictEqual(repository, "team/project");
397 return Effect.succeed({
398 items: [changeRequest(42, "2026-07-05T00:00:00Z")],
399 truncated: false,
400 continues: false,
401 });
402 },
403 }),
404 ],
405 resolveHandle: ({ context }) => {
406 assert.ok(context);
407 return Effect.succeed({
408 context: {
409 ...context,
410 provider: {
411 ...context.provider,
412 kind: SourceControlProviderKind.make("github"),
413 name: "GitHub Self-Hosted",
414 },
415 },
416 provider: undefined as never,
417 });
418 },
419 });
420 const result = yield* service.list({ state: "open" });
421 assert.deepStrictEqual(
422 result.entries.map(({ host, number }) => [host, number]),
423 [["code.example.test", 42]],
424 );
425 // Agents get the forge tools only where the host is one T3 reads.
426 assert.isTrue(yield* service.servesProject("p1" as ProjectId));
427 assert.isFalse(yield* service.servesProject("p2" as ProjectId));
428 }),
429 );
430
431 it.effect("derives a legacy repository host after refining its provider", () =>
432 Effect.gen(function* () {
433 const current = project({
434 id: "p1",
435 title: "legacy self-hosted",
436 workspaceRoot: "/gitlab",
437 repository: "group/project",
438 provider: SourceControlProviderKind.make("unknown"),
439 host: "code.example.test",
440 });
441 const identity = current.repositoryIdentity!;
442 const legacy = {
443 ...current,
444 repositoryIdentity: {
445 locator: identity.locator,
446 provider: identity.provider,
447 displayName: identity.displayName,
448 },
449 } as unknown as OrchestrationProjectShell;
450 const service = yield* makeService({
451 projects: [legacy],
452 providers: [fakePullRequestProvider(SourceControlProviderKind.make("gitlab"))],
453 resolveHandle: ({ context }) =>
454 Effect.succeed({
455 context: {
456 ...context!,
457 provider: { ...context!.provider, kind: SourceControlProviderKind.make("gitlab") },
458 },
459 provider: undefined as never,
460 }),
461 });
462
463 const result = yield* service.list({ state: "open", host: "gitlab" });
464
465 assert.strictEqual(result.providers[0]?.host, "gitlab");
466 assert.strictEqual(result.providers[0]?.kind, "gitlab");
467 }),
468 );
469
470 it.effect("tries another checkout when provider refinement remains unknown", () =>
471 Effect.gen(function* () {
472 const asked: string[] = [];
473 const selfHosted = project({
474 id: "p1",
475 title: "self-hosted",
476 workspaceRoot: "/gone",
477 repository: "group/project",
478 provider: SourceControlProviderKind.make("unknown"),
479 host: "code.example.test",
480 });
481 const service = yield* makeService({
482 projects: [selfHosted, { ...selfHosted, id: "p2" as ProjectId, workspaceRoot: "/healthy" }],
483 providers: [fakePullRequestProvider(SourceControlProviderKind.make("gitlab"))],
484 resolveHandle: ({ cwd, context }) => {
485 asked.push(cwd);
486 return cwd === "/gone"
487 ? Effect.succeed({ context: context!, provider: undefined as never })
488 : Effect.succeed({
489 context: {
490 ...context!,
491 provider: { ...context!.provider, kind: SourceControlProviderKind.make("gitlab") },
492 },
493 provider: undefined as never,
494 });
495 },
496 });
497
498 const result = yield* service.list({ state: "open" });
499
500 assert.deepStrictEqual(asked, ["/gone", "/healthy"]);
501 assert.strictEqual(result.providers[0]?.kind, "gitlab");
502 }),
503 );
504
505 function batchedChangeRequest(number: number, repository: string, updatedAt: string) {
506 return { ...changeRequest(number, updatedAt), repository };
507 }
508
509 it.effect("reads nothing from a host with no implementation, but reports it", () =>
510 Effect.gen(function* () {
511 const listed: string[] = [];
512 const service = yield* makeService({
513 projects: [
514 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
515 project({ id: "p2", title: "notes", workspaceRoot: "/b" }),
516 project({
517 id: "p3",
518 title: "on gitlab",
519 workspaceRoot: "/c",
520 repository: "group/project",
521 provider: SourceControlProviderKind.make("gitlab"),
522 }),
523 ],
524 providers: [
525 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
526 listChangeRequests: (input) => {
527 listed.push(input.repository);
528 return Effect.succeed({
529 items: [changeRequest(1, "2026-07-02T00:00:00Z")],
530 truncated: false,
531 continues: true,
532 });
533 },
534 }),
535 ],
536 });
537
538 const result = yield* service.list({ state: "open" });
539
540 assert.deepStrictEqual(listed, ["pingdotgg/t3code"]);
541 assert.strictEqual(result.entries[0]?.provider, "github");
542 assert.deepStrictEqual(
543 result.providers.map((summary) => ({
544 kind: summary.kind,
545 configured: summary.configured,
546 projectCount: summary.projectCount,
547 })),
548 [
549 { kind: SourceControlProviderKind.make("github"), configured: true, projectCount: 1 },
550 { kind: SourceControlProviderKind.make("gitlab"), configured: false, projectCount: 1 },
551 ],
552 );
553 }),
554 );
555
556 it.effect("reads nothing from a host its provider does not serve, but reports it", () =>
557 Effect.gen(function* () {
558 const reached = new Set<string>();
559 const bitbucket = (id: string, host: string) =>
560 project({
561 id,
562 title: host,
563 workspaceRoot: `/${id}`,
564 repository: "proj/repo",
565 provider: SourceControlProviderKind.make("bitbucket"),
566 host,
567 });
568 const service = yield* makeService({
569 projects: [bitbucket("p1", "bitbucket.org"), bitbucket("p2", "bitbucket.example.com")],
570 providers: [
571 fakePullRequestProvider(SourceControlProviderKind.make("bitbucket"), {
572 servesHost: (host) => host === "bitbucket.org",
573 getViewer: ({ host }) => {
574 reached.add(host ?? "");
575 return Effect.succeed("bilal");
576 },
577 listChangeRequests: ({ host }) => {
578 reached.add(host);
579 return Effect.succeed({ items: [], truncated: false, continues: false });
580 },
581 }),
582 ],
583 });
584
585 const result = yield* service.list({ state: "open" });
586
587 assert.deepStrictEqual([...reached], ["bitbucket.org"]);
588 assert.deepStrictEqual(
589 result.providers.map(({ host, configured, detail }) => ({ host, configured, detail })),
590 [
591 { host: "bitbucket.org", configured: true, detail: null },
592 {
593 host: "bitbucket.example.com",
594 configured: false,
595 detail: "This host cannot be browsed here yet.",
596 },
597 ],
598 );
599 }),
600 );
601
602 it.effect("says where each repository carries on, and from nothing it has run out of", () =>
603 Effect.gen(function* () {
604 const service = yield* makeService({
605 projects: [
606 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
607 project({ id: "p2", title: "web", workspaceRoot: "/b", repository: "acme/web" }),
608 ],
609 providers: [
610 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
611 listChangeRequests: ({ repository }) =>
612 Effect.succeed({
613 items: [changeRequest(1, "2026-07-02T00:00:00Z")],
614 truncated: repository === "pingdotgg/t3code",
615 continues: true,
616 }),
617 }),
618 ],
619 });
620
621 const result = yield* service.list({ state: "open" });
622
623 assert.deepStrictEqual(result.nextCursors, {
624 "github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|1|1",
625 });
626 }),
627 );
628
629 it.effect("uses a provider's raw cursor advance when it consumed malformed rows", () =>
630 Effect.gen(function* () {
631 const service = yield* makeService({
632 projects: [
633 project({
634 id: "p1",
635 title: "web",
636 workspaceRoot: "/a",
637 repository: "acme/web",
638 provider: SourceControlProviderKind.make("azure-devops"),
639 host: "dev.azure.com",
640 }),
641 ],
642 providers: [
643 fakePullRequestProvider(SourceControlProviderKind.make("azure-devops"), {
644 ...keyedByCanonicalKey,
645 listChangeRequests: () =>
646 Effect.succeed({
647 items: [changeRequest(7, "2026-07-02T00:00:00Z")],
648 truncated: true,
649 cursorAdvance: 4,
650 continues: true,
651 }),
652 }),
653 ],
654 });
655
656 const result = yield* service.list({ state: "open" });
657
658 assert.deepStrictEqual(result.nextCursors, {
659 "dev.azure.com dev.azure.com/acme/web": "2026-07-02T00:00:00Z|4|7",
660 });
661 }),
662 );
663
664 it.effect(
665 "continues a timestamp-paged host's listings through tied timestamps and terminates",
666 () =>
667 Effect.gen(function* () {
668 const boundary = "2026-10-12T00:00:00.000Z";
669 const older = "2026-10-11T00:00:00.000Z";
670 const rows = [1, 2, 3, 4, 5].map((number) =>
671 changeRequest(number, number <= 3 ? boundary : older),
672 );
673 const service = yield* makeService({
674 projects: [
675 project({
676 id: "p1",
677 title: "web",
678 workspaceRoot: "/w",
679 repository: "acme/web",
680 provider: "bitbucket",
681 host: "bitbucket.org",
682 }),
683 ],
684 providers: [
685 // Pages the way Bitbucket does: inclusively by update time, excluding rows already sent.
686 fakePullRequestProvider(SourceControlProviderKind.make("bitbucket"), {
687 listChangeRequests: ({ cursor, limit }) =>
688 Effect.sync(() => {
689 const seen = new Set(cursor?.seenAt ?? []);
690 const matching = rows.filter(
691 (row) =>
692 (cursor === undefined || row.updatedAt <= cursor.updatedBefore) &&
693 !seen.has(row.number),
694 );
695 return {
696 items: matching.slice(0, limit),
697 truncated: matching.length > limit,
698 continues: true,
699 };
700 }),
701 }),
702 ],
703 });
704 let page = yield* service.list({ state: "open", limit: 2 });
705 assert.deepStrictEqual(
706 page.entries.map((entry) => entry.number),
707 [1, 2],
708 );
709 for (const expected of [[3, 4], [5]]) {
710 assert.isTrue(page.truncated);
711 assert.isNotEmpty(page.nextCursors);
712 page = yield* service.list({ state: "open", limit: 2, cursors: page.nextCursors });
713 assert.deepStrictEqual(
714 page.entries.map((entry) => entry.number),
715 expected,
716 );
717 }
718 assert.isFalse(page.truncated);
719 assert.deepStrictEqual(page.nextCursors, {});
720 }),
721 );
722
723 it.effect("keeps a row already sent at the boundary instant from arriving twice", () =>
724 Effect.gen(function* () {
725 const service = yield* makeService({
726 projects: [
727 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
728 ],
729 providers: [
730 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
731 listChangeRequests: () =>
732 Effect.succeed({
733 items: [
734 changeRequest(7, "2026-07-02T00:00:00Z"),
735 changeRequest(8, "2026-07-02T00:00:00Z"),
736 changeRequest(9, "2026-07-01T00:00:00Z"),
737 ],
738 truncated: true,
739 continues: true,
740 }),
741 }),
742 ],
743 });
744
745 const result = yield* service.list({
746 state: "open",
747 cursors: { "github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|1|7" },
748 });
749
750 assert.deepStrictEqual(
751 result.entries.map((entry) => entry.number),
752 [8, 9],
753 );
754 assert.deepStrictEqual(result.nextCursors, {
755 "github.com pingdotgg/t3code": "2026-07-01T00:00:00Z|3|9",
756 });
757 }),
758 );
759
760 it.effect("keeps the earlier exclusions when a slice ends on the instant it began on", () =>
761 Effect.gen(function* () {
762 const service = yield* makeService({
763 projects: [
764 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
765 ],
766 providers: [
767 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
768 listChangeRequests: () =>
769 Effect.succeed({
770 items: [
771 changeRequest(7, "2026-07-02T00:00:00Z"),
772 changeRequest(8, "2026-07-02T00:00:00Z"),
773 ],
774 truncated: true,
775 continues: true,
776 }),
777 }),
778 ],
779 });
780
781 const result = yield* service.list({
782 state: "open",
783 cursors: { "github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|1|6" },
784 });
785
786 assert.deepStrictEqual(
787 result.entries.map((entry) => entry.number),
788 [7, 8],
789 );
790 assert.deepStrictEqual(result.nextCursors, {
791 "github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|3|6,7,8",
792 });
793 }),
794 );
795
796 it.effect("calls a transient viewer failure a failed operation, not a signed-out CLI", () =>
797 Effect.gen(function* () {
798 const service = yield* makeService({
799 projects: [
800 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
801 ],
802 providers: [
803 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
804 getViewer: () =>
805 Effect.fail(
806 new PullRequestProviderError({
807 provider: SourceControlProviderKind.make("github"),
808 operation: "getViewer",
809 reason: "failed",
810 detail: "HTTP 500",
811 }),
812 ),
813 }),
814 ],
815 });
816
817 const error = yield* Effect.flip(service.list({ state: "open" }));
818
819 assert.strictEqual(error._tag, "PullRequestOperationError");
820 }),
821 );
822
823 it.effect("reports an unusable host over a merely failing one", () =>
824 Effect.gen(function* () {
825 const service = yield* makeService({
826 projects: [
827 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
828 project({
829 id: "p2",
830 title: "on gitlab",
831 workspaceRoot: "/c",
832 repository: "group/project",
833 provider: SourceControlProviderKind.make("gitlab"),
834 }),
835 ],
836 providers: [
837 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
838 getViewer: () =>
839 Effect.fail(
840 new PullRequestProviderError({
841 provider: SourceControlProviderKind.make("github"),
842 operation: "getViewer",
843 reason: "failed",
844 detail: "HTTP 500",
845 }),
846 ),
847 }),
848 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
849 unavailableRequirement: {
850 missing: "Install glab.",
851 unauthenticated: "Run glab auth login.",
852 },
853 getViewer: () =>
854 Effect.fail(unusable(SourceControlProviderKind.make("gitlab"), "missing-tool")),
855 }),
856 ],
857 });
858
859 const error = yield* Effect.flip(service.list({ state: "open" }));
860
861 assert.strictEqual(error._tag, "PullRequestUnavailableError");
862 if (error._tag === "PullRequestUnavailableError") {
863 assert.strictEqual(error.requirement, "Install glab.");
864 }
865 assert.strictEqual(error.message, "Install glab.");
866 }),
867 );
868
869 it.effect("tells two hosts of one kind apart in the switcher and the filter", () =>
870 Effect.gen(function* () {
871 const service = yield* makeService({
872 projects: [
873 project({ id: "p1", title: "on github.com", workspaceRoot: "/a", repository: "ping/one" }),
874 project({
875 id: "p2",
876 title: "on the enterprise install",
877 workspaceRoot: "/b",
878 repository: "ping/two",
879 host: "ghe.example.com",
880 }),
881 ],
882 providers: [
883 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
884 listChangeRequests: ({ host }) =>
885 Effect.succeed({
886 items: host === "ghe.example.com" ? [changeRequest(2, "2026-07-05T00:00:00Z")] : [],
887 truncated: false,
888 continues: true,
889 }),
890 }),
891 ],
892 });
893
894 const all = yield* service.list({ state: "open" });
895 assert.deepStrictEqual(
896 all.providers.map((summary) => [summary.host, summary.kind, summary.projectCount]),
897 [
898 ["github.com", "github", 1],
899 ["ghe.example.com", "github", 1],
900 ],
901 );
902
903 const scoped = yield* service.list({ state: "open", host: "ghe.example.com" });
904 assert.deepStrictEqual(
905 scoped.entries.map((entry) => [entry.host, entry.number]),
906 [["ghe.example.com", 2]],
907 );
908 }),
909 );
910
911 it.effect("retains an unavailable host's summary when it is the only queried host", () =>
912 Effect.gen(function* () {
913 for (const reason of ["missing-tool", "unauthenticated"] as const) {
914 const service = yield* makeService({
915 projects: [
916 project({
917 id: "p1",
918 title: "t3code",
919 workspaceRoot: "/a",
920 repository: "pingdotgg/t3code",
921 }),
922 ],
923 providers: [
924 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
925 getViewer: () =>
926 Effect.fail(unusable(SourceControlProviderKind.make("github"), reason)),
927 }),
928 ],
929 });
930
931 for (const filter of [{}, { host: "github.com" }]) {
932 const error = yield* service.list({ state: "open", ...filter }).pipe(Effect.flip);
933 assert.strictEqual(error._tag, "PullRequestUnavailableError");
934 assert.strictEqual(
935 error._tag === "PullRequestUnavailableError" ? error.reason : null,
936 reason === "missing-tool" ? "cli-missing" : "cli-unauthenticated",
937 );
938 assert.isDefined(error.listResult);
939 const result = error.listResult!;
940 assert.deepStrictEqual(result.entries, []);
941 assert.deepStrictEqual(result.viewers, {});
942 assert.deepStrictEqual(
943 result.providers.map(({ host, configured, projectIds }) => ({
944 host,
945 configured,
946 projectIds: projectIds?.map(String),
947 })),
948 [{ host: "github.com", configured: false, projectIds: undefined }],
949 );
950 assert.strictEqual(result.providers[0]?.detail?.includes("github"), true);
951 assert.deepStrictEqual(
952 result.errors.map(({ projectId }) => projectId),
953 ["p1"],
954 );
955 }
956 }
957 }),
958 );
959
960 it.effect("retains a Bitbucket host summary when the provider rejects saved credentials", () =>
961 Effect.gen(function* () {
962 const provider = fakePullRequestProvider(SourceControlProviderKind.make("bitbucket"), {
963 getViewer: () =>
964 Effect.fail(
965 new PullRequestProviderError({
966 provider: SourceControlProviderKind.make("bitbucket"),
967 operation: "getViewer",
968 reason: "failed",
969 detail: "HTTP 403",
970 }),
971 ),
972 });
973 const service = yield* makeService({
974 projects: [
975 project({
976 id: "bitbucket",
977 title: "Widget",
978 workspaceRoot: "/widget",
979 repository: "acme/widget",
980 provider: "bitbucket",
981 host: "bitbucket.org",
982 }),
983 ],
984 providers: [provider],
985 });
986 for (const filter of [{}, { host: "bitbucket.org" }]) {
987 const error = yield* service.list({ state: "open", ...filter }).pipe(Effect.flip);
988 assert.strictEqual(error._tag, "PullRequestOperationError");
989 assert.isDefined(error.listResult);
990 const result = error.listResult!;
991 assert.deepStrictEqual(
992 result.providers.map(({ host, configured, projectIds }) => ({
993 host,
994 configured,
995 projectIds: projectIds?.map(String),
996 })),
997 [{ host: "bitbucket.org", configured: false, projectIds: undefined }],
998 );
999 assert.deepStrictEqual(result.entries, []);
1000 assert.deepStrictEqual(
1001 result.errors.map(({ projectId }) => projectId),
1002 ["bitbucket"],
1003 );
1004 }
1005 }),
1006 );
1007
1008 it.effect.each([
1009 {
1010 provider: "forgejo",
1011 host: "ssh.forge.example",
1012 remoteUrl: "ssh://git@ssh.forge.example:2222/team/repo.git",
1013 },
1014 {
1015 provider: "unknown",
1016 host: "forge.example",
1017 remoteUrl: "http://forge.example:3000/team/repo.git",
1018 },
1019 ])(
1020 "identifies every worktree behind an unavailable refined Forgejo authority",
1021 ({ provider, host, remoteUrl }) =>
1022 Effect.gen(function* () {
1023 const service = yield* makeService({
1024 projects: ["ssh", "ssh-worktree"].map((id) =>
1025 project({
1026 id,
1027 title: id,
1028 workspaceRoot: `/${id}`,
1029 repository: "team/repo",
1030 provider,
1031 host,
1032 remoteUrl,
1033 }),
1034 ),
1035 providers: [
1036 fakePullRequestProvider(SourceControlProviderKind.make("forgejo"), {
1037 getViewer: ({ host }) => {
1038 assert.strictEqual(host, "forge.example:3000");
1039 return Effect.fail(
1040 unusable(SourceControlProviderKind.make("forgejo"), "unauthenticated"),
1041 );
1042 },
1043 listChangeRequests: () => Effect.die("An unauthenticated host must not be queried"),
1044 }),
1045 ],
1046 resolveHandle: ({ context }) =>
1047 Effect.succeed({
1048 context: {
1049 ...context!,
1050 provider: {
1051 kind: SourceControlProviderKind.make("forgejo"),
1052 name: "Forgejo",
1053 baseUrl: "http://forge.example:3000",
1054 },
1055 },
1056 provider: undefined as never,
1057 }),
1058 });
1059 const error = yield* service.list({ state: "open" }).pipe(Effect.flip);
1060 assert.isDefined(error.listResult);
1061 const result = error.listResult!;
1062 assert.deepStrictEqual(
1063 result.providers.map(({ host, configured, projectIds }) => ({
1064 host,
1065 configured,
1066 projectIds: projectIds?.map(String),
1067 })),
1068 [{ host: "forge.example:3000", configured: false, projectIds: ["ssh", "ssh-worktree"] }],
1069 );
1070 assert.deepStrictEqual(result.entries, []);
1071 assert.deepStrictEqual(
1072 result.errors.map(({ projectId }) => projectId),
1073 ["ssh"],
1074 );
1075 }),
1076 );
1077
1078 it.effect("reads a repository once when several worktrees share it", () =>
1079 Effect.gen(function* () {
1080 let calls = 0;
1081 const service = yield* makeService({
1082 projects: [
1083 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
1084 project({
1085 id: "p2",
1086 title: "t3code worktree",
1087 workspaceRoot: "/b",
1088 repository: "PingDotGG/T3Code",
1089 }),
1090 ],
1091 providers: [
1092 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1093 listChangeRequests: () => {
1094 calls += 1;
1095 return Effect.succeed({
1096 items: [changeRequest(1, "2026-07-02T00:00:00Z")],
1097 truncated: false,
1098 continues: true,
1099 });
1100 },
1101 }),
1102 ],
1103 });
1104
1105 const result = yield* service.list({ state: "open" });
1106
1107 assert.strictEqual(calls, 1);
1108 assert.strictEqual(result.entries.length, 1);
1109 assert.isUndefined(result.providers[0]?.projectIds);
1110 }),
1111 );
1112
1113 it.effect("keeps healthy repositories when one of them cannot be read", () =>
1114 Effect.gen(function* () {
1115 const service = yield* makeService({
1116 projects: [
1117 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
1118 project({ id: "p2", title: "broken", workspaceRoot: "/b", repository: "pingdotgg/broken" }),
1119 ],
1120 providers: [
1121 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1122 listChangeRequests: (input) =>
1123 input.repository === "pingdotgg/broken"
1124 ? Effect.fail(requestFailed)
1125 : Effect.succeed({
1126 items: [changeRequest(1, "2026-07-02T00:00:00Z")],
1127 truncated: false,
1128 continues: true,
1129 }),
1130 }),
1131 ],
1132 });
1133
1134 const result = yield* service.list({ state: "open" });
1135
1136 assert.strictEqual(result.entries.length, 1);
1137 assert.deepStrictEqual(
1138 result.errors.map((error) => error.projectTitle),
1139 ["broken"],
1140 );
1141 }),
1142 );
1143
1144 it.effect("offers each label once across repositories, despite one that cannot be read", () =>
1145 Effect.gen(function* () {
1146 const reads: Array<string> = [];
1147 const service = yield* makeService({
1148 projects: [
1149 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
1150 project({
1151 id: "p5",
1152 title: "t3code worktree",
1153 workspaceRoot: "/e",
1154 repository: "pingdotgg/t3code",
1155 }),
1156 project({
1157 id: "p2",
1158 title: "uploadthing",
1159 workspaceRoot: "/b",
1160 repository: "pingdotgg/ut",
1161 }),
1162 project({ id: "p3", title: "broken", workspaceRoot: "/c", repository: "pingdotgg/broken" }),
1163 project({
1164 id: "p4",
1165 title: "elsewhere",
1166 workspaceRoot: "/d",
1167 repository: "group/app",
1168 provider: "gitlab",
1169 }),
1170 ],
1171 providers: [
1172 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1173 listRepositoryLabels: (input) => {
1174 reads.push(input.repository);
1175 return input.repository === "pingdotgg/broken"
1176 ? Effect.fail(requestFailed)
1177 : Effect.succeed({
1178 items:
1179 input.repository === "pingdotgg/t3code"
1180 ? [
1181 { name: "size:XL", color: "d93f0b" },
1182 { name: "bug", color: "d73a4a" },
1183 ]
1184 : [{ name: "Bug", color: "ee0701" }],
1185 truncated: false,
1186 });
1187 },
1188 }),
1189 // A host with no repository labels is left out rather than failing the answer.
1190 fakePullRequestProvider(SourceControlProviderKind.make("gitlab")),
1191 ],
1192 });
1193
1194 const result = yield* service.filterOptions({ kind: "labels" });
1195
1196 assert.deepStrictEqual(
1197 result.labels.map((label) => label.name),
1198 ["bug", "size:XL"],
1199 );
1200 assert.strictEqual(reads.filter((repository) => repository === "pingdotgg/t3code").length, 1);
1201 assert.strictEqual(result.truncated, false);
1202 }),
1203 );
1204
1205 it.effect("puts the author a query names exactly ahead of those it only begins", () =>
1206 Effect.gen(function* () {
1207 const queries: Array<string | undefined> = [];
1208 const service = yield* makeService({
1209 projects: [
1210 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
1211 ],
1212 providers: [
1213 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1214 searchRepositoryAuthors: (input) => {
1215 queries.push(input.query);
1216 return Effect.succeed({
1217 items: [
1218 { login: "theo-browne", name: null, avatarUrl: null },
1219 { login: "octocat", name: "Theo", avatarUrl: null },
1220 { login: "julius", name: "Julius", avatarUrl: null },
1221 { login: "t3dotgg", name: "theo", avatarUrl: null },
1222 ],
1223 truncated: true,
1224 });
1225 },
1226 }),
1227 ],
1228 });
1229
1230 const result = yield* service.filterOptions({ kind: "authors", query: "theo" });
1231
1232 assert.deepStrictEqual(queries, ["theo"]);
1233 assert.deepStrictEqual(
1234 result.authors.map((author) => author.login),
1235 ["octocat", "t3dotgg", "theo-browne"],
1236 );
1237 assert.strictEqual(result.truncated, true);
1238 }),
1239 );
1240
1241 it.effect("ranks references by number, keeping the host's recent-first order", () =>
1242 Effect.gen(function* () {
1243 const service = yield* makeService({
1244 projects: [
1245 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
1246 project({ id: "p2", title: "tree", workspaceRoot: "/b", repository: "pingdotgg/t3code" }),
1247 ],
1248 providers: [
1249 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1250 searchRepositoryReferences: () =>
1251 Effect.succeed({
1252 items: [
1253 { reference: "#129", kind: "issue", number: 129, title: "Newest", state: "open" },
1254 {
1255 reference: "#7",
1256 kind: "issue",
1257 number: 7,
1258 title: "Fix #12 again",
1259 state: "open",
1260 },
1261 {
1262 reference: "#12",
1263 kind: "change-request",
1264 number: 12,
1265 title: "Exact",
1266 state: "merged",
1267 },
1268 { reference: "#120", kind: "issue", number: 120, title: "Older", state: "closed" },
1269 ],
1270 truncated: false,
1271 }),
1272 }),
1273 ],
1274 });
1275
1276 const result = yield* service.filterOptions({ kind: "references", query: "12" });
1277
1278 assert.deepStrictEqual(
1279 result.references.map((candidate) => candidate.reference),
1280 ["#12", "#129", "#120", "#7"],
1281 );
1282 }),
1283 );
1284
1285 it.effect("tries another workspace on the same host for the viewer", () =>
1286 Effect.gen(function* () {
1287 const service = yield* makeService({
1288 projects: [
1289 project({ id: "p1", title: "broken", workspaceRoot: "/broken", repository: "acme/one" }),
1290 project({ id: "p2", title: "healthy", workspaceRoot: "/healthy", repository: "acme/two" }),
1291 ],
1292 providers: [
1293 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1294 getViewer: (input) =>
1295 input.cwd === "/healthy"
1296 ? Effect.succeed("bilal")
1297 : Effect.fail(unusable(SourceControlProviderKind.make("github"), "missing-tool")),
1298 listChangeRequests: () =>
1299 Effect.succeed({
1300 items: [changeRequest(1, "2026-07-02T00:00:00Z")],
1301 truncated: false,
1302 continues: true,
1303 }),
1304 }),
1305 ],
1306 });
1307
1308 const result = yield* service.list({ state: "open" });
1309
1310 assert.strictEqual(result.entries.length, 2);
1311 assert.strictEqual(result.viewers["github.com"], "bilal");
1312 }),
1313 );
1314
1315 it.effect("routing verifies the current account on the requested host without caching it", () =>
1316 Effect.gen(function* () {
1317 let viewer = "first-account";
1318 const service = yield* makeService({
1319 projects: [
1320 project({
1321 id: "p1",
1322 title: "web",
1323 workspaceRoot: "/a",
1324 repository: "acme/web",
1325 host: "github.example.test",
1326 }),
1327 ],
1328 providers: [
1329 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1330 getRoutingIdentity: (input) => {
1331 assert.deepStrictEqual(input, { cwd: "/a", host: "github.example.test" });
1332 return Effect.succeed({
1333 viewer,
1334 accountId: viewer === "first-account" ? "123" : "456",
1335 });
1336 },
1337 }),
1338 ],
1339 });
1340 const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1341 assert.deepStrictEqual(yield* service.routing(ref), {
1342 host: "github.example.test",
1343 provider: SourceControlProviderKind.make("github"),
1344 viewer: "first-account",
1345 accountId: "123",
1346 projectTitle: "web",
1347 workspaceRoot: "/a",
1348 });
1349 viewer = "second-account";
1350 assert.strictEqual((yield* service.routing(ref)).viewer, "second-account");
1351 viewer = " ";
1352 const failure = yield* service.routing(ref).pipe(Effect.flip);
1353 assert.strictEqual(failure._tag, "PullRequestOperationError");
1354 if (failure._tag === "PullRequestOperationError") {
1355 assert.strictEqual(failure.operation, "routeIdentity");
1356 }
1357 }),
1358 );
1359
1360 it.effect("refuses an action the host never claimed it could run", () =>
1361 Effect.gen(function* () {
1362 let ran = false;
1363 const service = yield* makeService({
1364 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
1365 providers: [
1366 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1367 capabilities: {
1368 diff: true,
1369 comment: true,
1370 actions: ["merge", "close"],
1371 mergeMethods: ["merge"],
1372 search: true,
1373 reactions: true,
1374 review: FULL_REVIEW,
1375 reviewers: FULL_REVIEWERS,
1376 },
1377 runAction: () => {
1378 ran = true;
1379 return Effect.void;
1380 },
1381 }),
1382 ],
1383 });
1384
1385 const error = yield* Effect.flip(
1386 service.runAction({
1387 projectId: "p1" as ProjectId,
1388 repository: "acme/web",
1389 number: 1,
1390 action: "reopen",
1391 }),
1392 );
1393
1394 assert.strictEqual(error._tag, "PullRequestOperationError");
1395 assert.isFalse(ran);
1396 }),
1397 );
1398
1399 it.effect(
1400 "asks to remove agent credits on merge only from a host that rewrites merge messages",
1401 () =>
1402 Effect.gen(function* () {
1403 const asked: Array<boolean | undefined> = [];
1404 const runAction: PullRequestProviderApi["runAction"] = (input) =>
1405 Effect.sync(() => {
1406 asked.push(input.removeAgentCreditsOnMerge);
1407 });
1408 for (const rewrites of [true, false]) {
1409 const service = yield* makeService({
1410 settings: { ...DEFAULT_SERVER_SETTINGS, removeAgentCreditsOnMerge: true },
1411 projects: [
1412 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
1413 ],
1414 providers: [
1415 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1416 runAction,
1417 getChangeRequestSummary: () =>
1418 Effect.succeed(changeRequest(1, "2026-09-03T00:00:00Z")),
1419 ...(rewrites ? { mergeMessageRewrite: (message: string) => message } : {}),
1420 }),
1421 ],
1422 });
1423 yield* service.runAction({
1424 projectId: "p1" as ProjectId,
1425 repository: "acme/web",
1426 number: 1,
1427 action: "merge",
1428 });
1429 }
1430 assert.deepStrictEqual(asked, [true, undefined]);
1431 }),
1432 );
1433
1434 it.effect(
1435 "reads logs of the failing checks, or of the one named, and names the checks it lacks",
1436 () =>
1437 Effect.gen(function* () {
1438 const asked: Array<ReadonlyArray<string>> = [];
1439 let failing = 0;
1440 const check = (name: string, status: "success" | "failure" | "cancelled") => ({
1441 name,
1442 status,
1443 description: null,
1444 url: `https://github.com/acme/web/runs/${name.length}`,
1445 });
1446 const service = yield* makeService({
1447 projects: [
1448 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
1449 ],
1450 providers: [
1451 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1452 getChangeRequestChecks: () =>
1453 Effect.succeed({
1454 state: "open",
1455 checks: [
1456 check("Lint", "success"),
1457 check("Test", "failure"),
1458 check("E2E", "cancelled"),
1459 ...Array.from({ length: failing }, (_, index) =>
1460 check(`Shard ${index}`, "failure"),
1461 ),
1462 ],
1463 }),
1464 getCheckLogs: (input) =>
1465 Effect.sync(() => {
1466 asked.push(input.checks.map((entry) => entry.name));
1467 return input.checks.map((entry) => ({
1468 ...entry,
1469 log: "boom",
1470 truncated: false,
1471 detail: null,
1472 }));
1473 }),
1474 }),
1475 ],
1476 });
1477 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1478 yield* service.checkLogs({ ...reference, tailLines: 50 });
1479 yield* service.checkLogs({ ...reference, check: "lint", tailLines: 50 });
1480 const missing = yield* Effect.flip(
1481 service.checkLogs({ ...reference, check: "Deploy", tailLines: 50 }),
1482 );
1483 assert.deepStrictEqual(asked, [["Test", "E2E"], ["Lint"]]);
1484 assert.include(missing.message, "Lint, Test, E2E");
1485
1486 failing = 6;
1487 asked.length = 0;
1488 const many = yield* service.checkLogs({ ...reference, tailLines: 50 });
1489 // The host is asked for five; the other three come back unread, by name.
1490 assert.lengthOf(asked[0] ?? [], 5);
1491 assert.deepStrictEqual(
1492 many.map((log) => [log.name, log.log]),
1493 [
1494 ["Test", "boom"],
1495 ["E2E", "boom"],
1496 ["Shard 0", "boom"],
1497 ["Shard 1", "boom"],
1498 ["Shard 2", "boom"],
1499 ["Shard 3", null],
1500 ["Shard 4", null],
1501 ["Shard 5", null],
1502 ],
1503 );
1504 assert.include(many.at(-1)?.detail ?? "", "Ask for this check by name");
1505 }),
1506 );
1507
1508 it.effect.each([false, true])(
1509 "re-reads checks after a rerun instead of serving the failed ones (rerun fails: %s)",
1510 (failAfterRerun) =>
1511 Effect.gen(function* () {
1512 let rerun = false;
1513 const service = yield* makeService({
1514 projects: [
1515 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
1516 ],
1517 providers: [
1518 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1519 getChangeRequestChecks: () =>
1520 Effect.succeed({
1521 state: "open" as const,
1522 checks: [
1523 {
1524 name: "Test",
1525 status: rerun ? ("pending" as const) : ("failure" as const),
1526 description: null,
1527 url: null,
1528 },
1529 ],
1530 }),
1531 // A failure can come after one run already restarted.
1532 rerunChecks: (input) =>
1533 Effect.suspend(() => {
1534 rerun = true;
1535 return failAfterRerun
1536 ? Effect.fail(requestFailed)
1537 : Effect.succeed(
1538 input.checks.map((check) => ({ ...check, rerun: true, detail: null })),
1539 );
1540 }),
1541 }),
1542 ],
1543 });
1544 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1545 assert.equal((yield* service.checks(reference))?.checks[0]?.status, "failure");
1546 yield* service.rerunChecks(reference).pipe(Effect.ignore);
1547 assert.equal((yield* service.checks(reference))?.checks[0]?.status, "pending");
1548 }),
1549 );
1550
1551 it.effect("refuses a merge whose head moved past expectedHeadSha and pins the host merge", () =>
1552 Effect.gen(function* () {
1553 const head = "0a1b2c3d4e5f60718293a4b5c6d7e8f901234567";
1554 const pinned: Array<string | undefined> = [];
1555 const service = yield* makeService({
1556 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
1557 providers: [
1558 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1559 getChangeRequest: () => Effect.succeed({ ...hostedChangeRequest("Body"), headSha: head }),
1560 getChangeRequestSummary: () => Effect.succeed(changeRequest(1, "2026-09-03T00:00:00Z")),
1561 runAction: (input) => Effect.sync(() => void pinned.push(input.expectedHeadSha)),
1562 }),
1563 ],
1564 });
1565 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1566 const refused = yield* Effect.flip(
1567 service.runAction({ ...reference, action: "merge", expectedHeadSha: "0a1b2c4" }),
1568 );
1569 assert.include(refused.message, head);
1570 const tooShort = yield* Effect.flip(
1571 service.runAction({ ...reference, action: "merge", expectedHeadSha: "0a1b2c" }),
1572 );
1573 assert.include(tooShort.message, head);
1574 yield* service.runAction({ ...reference, action: "merge", expectedHeadSha: head });
1575 yield* service.runAction({ ...reference, action: "merge", expectedHeadSha: "0A1B2C3D4" });
1576 assert.deepStrictEqual(pinned, [head, head]);
1577 }),
1578 );
1579
1580 it.effect("publishes a merge for immediate settlement only after host confirmation", () =>
1581 Effect.gen(function* () {
1582 const mergedAt = "2026-09-03T02:00:00.000Z";
1583 let state: "open" | "merged" = "open";
1584 let confirmationFails = false;
1585 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1586 const service = yield* makeService({
1587 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
1588 providers: [
1589 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1590 getChangeRequestSummary: () =>
1591 confirmationFails
1592 ? Effect.fail(
1593 new PullRequestProviderError({
1594 provider: SourceControlProviderKind.make("github"),
1595 operation: "getChangeRequestSummary",
1596 reason: "failed",
1597 detail: "HTTP 504",
1598 }),
1599 )
1600 : Effect.succeed({ ...changeRequest(1, mergedAt), state, mergedAt }),
1601 }),
1602 ],
1603 });
1604 const merges = yield* service.subscribeMerges;
1605 const observedMerge = yield* Stream.runHead(merges).pipe(
1606 Effect.forkChild({ startImmediately: true }),
1607 );
1608
1609 assert.isUndefined(yield* service.runAction({ ...reference, action: "merge" }));
1610 const queuedRefresh = Option.getOrThrow(yield* Stream.runHead(service.subscribeRefreshes));
1611 confirmationFails = true;
1612 yield* service.runAction({ ...reference, action: "merge" });
1613 assert.isAbove(
1614 Option.getOrThrow(yield* Stream.runHead(service.subscribeRefreshes)),
1615 queuedRefresh,
1616 );
1617 confirmationFails = false;
1618 state = "merged";
1619 // The event carries the host's merge time, not the moment the confirmation ran.
1620 yield* TestClock.setTime(Date.parse(mergedAt) + 60_000);
1621 yield* service.runAction({
1622 ...reference,
1623 repository: " ACME/WEB ",
1624 action: "merge",
1625 mergeMethod: "merge",
1626 });
1627
1628 assert.deepStrictEqual(Option.getOrThrow(yield* Fiber.join(observedMerge)), {
1629 ...reference,
1630 mergedAt,
1631 });
1632 }),
1633 );
1634
1635 it.effect("returns the host's merged reply as a summary and trusts it without another read", () =>
1636 Effect.gen(function* () {
1637 const mergedAt = "2026-09-03T02:00:00.000Z";
1638 const merged = {
1639 number: 1,
1640 title: "Change request 1",
1641 url: "https://host/pull/1",
1642 headBranch: "feat/1",
1643 baseBranch: "main",
1644 state: "merged" as const,
1645 isDraft: false,
1646 updatedAt: mergedAt,
1647 mergedAt,
1648 headSha: "abc123",
1649 autoMergeEnabled: false,
1650 };
1651 let summaryReads = 0;
1652 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1653 const service = yield* makeService({
1654 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
1655 providers: [
1656 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1657 runAction: () => Effect.succeed(merged),
1658 getChangeRequestSummary: () =>
1659 Effect.sync(() => {
1660 summaryReads++;
1661 return { ...changeRequest(1, mergedAt), state: "merged" as const, mergedAt };
1662 }),
1663 }),
1664 ],
1665 });
1666 const merges = yield* service.subscribeMerges;
1667 const observedMerge = yield* Stream.runHead(merges).pipe(
1668 Effect.forkChild({ startImmediately: true }),
1669 );
1670 const observedAt = Date.parse("2026-09-03T02:00:01.000Z");
1671 yield* TestClock.setTime(observedAt);
1672
1673 // Clients that did not ask decode the success as void, so they must get nothing back.
1674 assert.isUndefined(yield* service.runAction({ ...reference, action: "merge" }));
1675 const result = yield* service.runAction({
1676 ...reference,
1677 action: "merge",
1678 replyWithSummary: true,
1679 });
1680
1681 assert.deepStrictEqual(result, {
1682 ...merged,
1683 provider: SourceControlProviderKind.make("github"),
1684 projectId: reference.projectId,
1685 repository: reference.repository,
1686 observedAt,
1687 });
1688 assert.strictEqual(summaryReads, 0);
1689 assert.deepStrictEqual(Option.getOrThrow(yield* Fiber.join(observedMerge)), {
1690 ...reference,
1691 mergedAt,
1692 });
1693 }),
1694 );
1695
1696 it.effect("refreshes every reader before a queued merge confirmation finishes", () =>
1697 Effect.gen(function* () {
1698 const confirmationStarted = yield* Deferred.make<void>();
1699 const confirm = yield* Deferred.make<void>();
1700 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1701 const service = yield* makeService({
1702 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
1703 providers: [
1704 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1705 getChangeRequestSummary: () =>
1706 Effect.gen(function* () {
1707 yield* Deferred.succeed(confirmationStarted, undefined);
1708 yield* Deferred.await(confirm);
1709 return changeRequest(1, "2026-09-16T00:00:00.000Z");
1710 }),
1711 }),
1712 ],
1713 });
1714 const merges = yield* service.subscribeMerges;
1715 const observedMerge = yield* Stream.runHead(merges).pipe(
1716 Effect.forkChild({ startImmediately: true }),
1717 );
1718 const readers = yield* Effect.forEach([0, 1], () =>
1719 Stream.runHead(service.subscribeRefreshes).pipe(Effect.forkChild({ startImmediately: true })),
1720 );
1721 const action = yield* service
1722 .runAction({ ...reference, action: "merge" })
1723 .pipe(Effect.forkChild({ startImmediately: true }));
1724 yield* Deferred.await(confirmationStarted);
1725 const revisions = yield* Effect.forEach(readers, (reader) =>
1726 Fiber.join(reader).pipe(Effect.map(Option.getOrThrow)),
1727 );
1728 assert.isAbove(revisions[0]!, 0);
1729 assert.strictEqual(revisions[0], revisions[1]);
1730 assert.isUndefined(action.pollUnsafe());
1731 yield* Deferred.succeed(confirm, undefined);
1732 yield* Fiber.join(action);
1733 assert.isUndefined(observedMerge.pollUnsafe());
1734 }),
1735 );
1736
1737 it.effect("runs branch deletion only when the host and viewer support it, never for a stack", () =>
1738 Effect.gen(function* () {
1739 let actions = 0;
1740 let supported = false;
1741 let allowed = true;
1742 const base = fakePullRequestProvider(SourceControlProviderKind.make("github"));
1743 const service = yield* makeService({
1744 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
1745 providers: [
1746 {
1747 ...base,
1748 capabilities: {
1749 ...base.capabilities,
1750 actions: ["delete-branch"],
1751 stackActions: true,
1752 get deleteBranch() {
1753 return supported;
1754 },
1755 },
1756 getViewerPermissions: () =>
1757 Effect.succeed({
1758 actions: allowed ? ["delete-branch"] : [],
1759 comment: true,
1760 resolve: true,
1761 verdicts: [],
1762 requestReviewers: false,
1763 }),
1764 runAction: (input) =>
1765 Effect.sync(() => {
1766 assert.strictEqual(input.action, "delete-branch");
1767 actions++;
1768 }),
1769 },
1770 ],
1771 });
1772 const input = {
1773 projectId: "p1" as ProjectId,
1774 repository: "acme/web",
1775 number: 1,
1776 action: "delete-branch" as const,
1777 };
1778 assert.strictEqual(
1779 (yield* Effect.flip(service.runAction(input)))._tag,
1780 "PullRequestOperationError",
1781 );
1782 assert.strictEqual(actions, 0);
1783 supported = true;
1784 assert.strictEqual(
1785 (yield* Effect.flip(
1786 service.runAction({
1787 ...input,
1788 stackNumber: 2,
1789 expectedStackHeads: [{ number: 1, headSha: "abc123" }],
1790 }),
1791 ))._tag,
1792 "PullRequestOperationError",
1793 );
1794 assert.strictEqual(actions, 0);
1795 allowed = false;
1796 assert.strictEqual(
1797 (yield* Effect.flip(service.runAction(input)))._tag,
1798 "PullRequestOperationError",
1799 );
1800 assert.strictEqual(actions, 0);
1801 allowed = true;
1802 yield* service.runAction(input);
1803 assert.strictEqual(actions, 1);
1804 }),
1805 );
1806
1807 it.effect("checks and deletes a branch inside one verified credential", () =>
1808 Effect.gen(function* () {
1809 let pinned = false;
1810 const calls: Array<string> = [];
1811 const service = yield* makeService({
1812 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
1813 providers: [
1814 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1815 capabilities: {
1816 ...fakePullRequestProvider("github").capabilities,
1817 actions: ["delete-branch"],
1818 deleteBranch: true,
1819 },
1820 withVerifiedCredential: (_, use) =>
1821 Effect.suspend(() => {
1822 pinned = true;
1823 return use({ accountId: "101", viewer: "bilal", credentialFingerprint: "a" });
1824 }).pipe(Effect.ensuring(Effect.sync(() => (pinned = false)))),
1825 getViewerPermissions: () =>
1826 Effect.sync(() => {
1827 calls.push(`permissions pinned=${pinned}`);
1828 return {
1829 actions: ["delete-branch"],
1830 comment: true,
1831 resolve: true,
1832 verdicts: [],
1833 requestReviewers: false,
1834 };
1835 }),
1836 runAction: (input) =>
1837 Effect.sync(() => {
1838 calls.push(`${input.action} pinned=${pinned}`);
1839 }),
1840 }),
1841 ],
1842 });
1843 yield* service.runAction({
1844 projectId: "p1" as ProjectId,
1845 repository: "acme/web",
1846 number: 1,
1847 action: "delete-branch",
1848 });
1849 assert.deepStrictEqual(calls, ["permissions pinned=true", "delete-branch pinned=true"]);
1850 }),
1851 );
1852
1853 it.effect("refuses an action this viewer may not take, and says what access it takes", () =>
1854 Effect.gen(function* () {
1855 let ran: string | null = null;
1856 const service = yield* makeService({
1857 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
1858 providers: [
1859 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1860 getViewerPermissions: () =>
1861 Effect.succeed({
1862 actions: ["ready", "draft", "close", "reopen"],
1863 comment: true,
1864 resolve: true,
1865 verdicts: ["comment", "approve", "request-changes"],
1866 requestReviewers: false,
1867 }),
1868 runAction: (input) => {
1869 ran = input.action;
1870 return Effect.void;
1871 },
1872 }),
1873 ],
1874 });
1875 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1876
1877 const error = yield* Effect.flip(service.runAction({ ...reference, action: "merge" }));
1878 assert.strictEqual(error._tag, "PullRequestOperationError");
1879 assert.include(error.message, "You need write access on this repository to merge.");
1880 assert.strictEqual(ran, null);
1881
1882 yield* service.runAction({ ...reference, action: "close" });
1883 assert.strictEqual(ran, "close");
1884 }),
1885 );
1886
1887 it.effect("gates arming a merge for later exactly as it gates merging now", () =>
1888 Effect.gen(function* () {
1889 let ranWith: { readonly action: string; readonly mergeMethod?: string } | null = null;
1890 const service = yield* makeService({
1891 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
1892 providers: [
1893 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1894 capabilities: {
1895 diff: true,
1896 comment: true,
1897 actions: ["merge", "close", "enable-auto-merge", "disable-auto-merge"],
1898 mergeMethods: ["merge", "squash"],
1899 search: true,
1900 reactions: true,
1901 review: FULL_REVIEW,
1902 reviewers: FULL_REVIEWERS,
1903 },
1904 getViewerPermissions: () =>
1905 Effect.succeed({
1906 actions: ["close"],
1907 comment: true,
1908 resolve: true,
1909 verdicts: ["comment", "approve", "request-changes"],
1910 requestReviewers: false,
1911 }),
1912 runAction: (input) => {
1913 ranWith = {
1914 action: input.action,
1915 ...(input.mergeMethod === undefined ? {} : { mergeMethod: input.mergeMethod }),
1916 };
1917 return Effect.void;
1918 },
1919 }),
1920 ],
1921 });
1922 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
1923
1924 const refused = yield* Effect.flip(
1925 service.runAction({ ...reference, action: "enable-auto-merge", mergeMethod: "squash" }),
1926 );
1927 assert.strictEqual(refused._tag, "PullRequestOperationError");
1928 assert.include(refused.message, "the repository has to allow it");
1929 assert.strictEqual(ranWith, null);
1930
1931 const wrongStrategy = yield* Effect.flip(
1932 service.runAction({ ...reference, action: "enable-auto-merge", mergeMethod: "rebase" }),
1933 );
1934 assert.strictEqual(wrongStrategy._tag, "PullRequestOperationError");
1935 assert.strictEqual(ranWith, null);
1936 }),
1937 );
1938
1939 it.effect("keeps two hosts of one provider kind as two accounts", () =>
1940 Effect.gen(function* () {
1941 const viewerFor: Record<string, string> = { "/cloud": "bilal", "/enterprise": "b.hassan" };
1942 const service = yield* makeService({
1943 projects: [
1944 project({ id: "p1", title: "cloud", workspaceRoot: "/cloud", repository: "acme/web" }),
1945 project({
1946 id: "p2",
1947 title: "enterprise",
1948 workspaceRoot: "/enterprise",
1949 repository: "acme/web",
1950 host: "github.acme.dev",
1951 }),
1952 ],
1953 providers: [
1954 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1955 getViewer: (input) => Effect.succeed(viewerFor[input.cwd] ?? "unknown"),
1956 listChangeRequests: () =>
1957 Effect.succeed({
1958 items: [changeRequest(1, "2026-07-02T00:00:00Z")],
1959 truncated: false,
1960 continues: true,
1961 }),
1962 }),
1963 ],
1964 });
1965
1966 const result = yield* service.list({ state: "open" });
1967
1968 assert.strictEqual(result.entries.length, 2);
1969 assert.deepStrictEqual(result.viewers, {
1970 "github.com": "bilal",
1971 "github.acme.dev": "b.hassan",
1972 });
1973 assert.deepStrictEqual(result.entries.map((entry) => entry.host).toSorted(), [
1974 "github.acme.dev",
1975 "github.com",
1976 ]);
1977 }),
1978 );
1979
1980 it.effect("stops new reads after a rate limit while leaving manual actions available", () =>
1981 Effect.gen(function* () {
1982 let listCalls = 0;
1983 let actionCalls = 0;
1984 const service = yield* makeService({
1985 projects: [
1986 project({ id: "p1", title: "cloud", workspaceRoot: "/cloud", repository: "acme/web" }),
1987 ],
1988 providers: [
1989 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
1990 listChangeRequests: () =>
1991 Effect.sync(() => {
1992 listCalls += 1;
1993 }).pipe(
1994 Effect.andThen(
1995 Effect.fail(
1996 new PullRequestProviderError({
1997 provider: SourceControlProviderKind.make("github"),
1998 operation: "listChangeRequests",
1999 reason: "rate-limited",
2000 detail: "GitHub API rate limit exceeded.",
2001 }),
2002 ),
2003 ),
2004 ),
2005 runAction: () =>
2006 Effect.sync(() => {
2007 actionCalls += 1;
2008 }),
2009 }),
2010 ],
2011 });
2012
2013 const first = yield* service.list({ state: "open", involvement: "all" });
2014 const paused = yield* service.list({ state: "open", involvement: "authored" });
2015 yield* service.runAction({
2016 projectId: "p1" as ProjectId,
2017 repository: "acme/web",
2018 number: 1,
2019 action: "close",
2020 });
2021
2022 assert.strictEqual(listCalls, 1);
2023 assert.strictEqual(actionCalls, 1);
2024 assert.lengthOf(first.errors, 1);
2025 assert.lengthOf(paused.errors, 1);
2026 }),
2027 );
2028
2029 it.effect(
2030 "opening a pull request during a rate-limit pause still reads its detail and activity",
2031 () =>
2032 Effect.gen(function* () {
2033 let detailReads = 0;
2034 let activityReads = 0;
2035 const service = yield* makeService({
2036 projects: [
2037 project({ id: "p1", title: "cloud", workspaceRoot: "/cloud", repository: "acme/web" }),
2038 ],
2039 providers: [
2040 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2041 getChangeRequest: ({ number }) =>
2042 Effect.suspend(() => {
2043 detailReads += 1;
2044 return number === 1
2045 ? Effect.fail(
2046 new PullRequestProviderError({
2047 provider: SourceControlProviderKind.make("github"),
2048 operation: "getChangeRequest",
2049 reason: "rate-limited",
2050 detail: "GitHub API rate limit exceeded.",
2051 }),
2052 )
2053 : Effect.succeed({ ...hostedChangeRequest("Body"), number });
2054 }),
2055 getChangeRequestActivity: () =>
2056 Effect.sync(() => {
2057 activityReads += 1;
2058 return {
2059 comments: [],
2060 commentCount: 0,
2061 commentsTruncated: false,
2062 reviewThreads: [],
2063 commits: [],
2064 };
2065 }),
2066 }),
2067 ],
2068 });
2069 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 2 };
2070
2071 yield* Effect.result(service.detail({ ...reference, number: 1 }));
2072 const background = yield* Effect.result(service.detail(reference));
2073 const opened = yield* Effect.result(
2074 service
2075 .detail(reference)
2076 .pipe(Effect.provideService(SourceControlRateLimit.Interactive, true)),
2077 );
2078 const timeline = yield* Effect.result(
2079 service
2080 .activity(reference)
2081 .pipe(Effect.provideService(SourceControlRateLimit.Interactive, true)),
2082 );
2083
2084 expect(background).toMatchObject({ _tag: "Failure" });
2085 expect({ opened, timeline }).toMatchObject({
2086 opened: { _tag: "Success", success: { number: 2 } },
2087 timeline: { _tag: "Success", success: { commentCount: 0 } },
2088 });
2089 assert.strictEqual(detailReads, 2);
2090 assert.strictEqual(activityReads, 1);
2091 }),
2092 );
2093
2094 it.effect("refuses a repository that does not belong to the requested project", () =>
2095 Effect.gen(function* () {
2096 const service = yield* makeService({
2097 projects: [
2098 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
2099 ],
2100 providers: [fakePullRequestProvider(SourceControlProviderKind.make("github"))],
2101 });
2102
2103 const error = yield* service
2104 .diff({ projectId: "p1" as ProjectId, repository: "attacker/repo", number: 1 })
2105 .pipe(Effect.flip);
2106
2107 assert.strictEqual(error._tag, "PullRequestOperationError");
2108 }),
2109 );
2110
2111 it.effect("routes explicit Forgejo HTTP authorities through SSH checkouts after refinement", () =>
2112 Effect.gen(function* () {
2113 for (const provider of ["forgejo", "unknown"] as const) {
2114 const seen: string[] = [];
2115 const viewers: Array<string | undefined> = [];
2116 const service = yield* makeService({
2117 projects: [
2118 project({
2119 id: "ssh",
2120 title: "ssh",
2121 workspaceRoot: "/ssh",
2122 repository: "team/repo",
2123 provider,
2124 host: "ssh.code.example",
2125 remoteUrl: "git@ssh.code.example:team/repo.git",
2126 }),
2127 ],
2128 providers: [
2129 fakePullRequestProvider(SourceControlProviderKind.make("forgejo"), {
2130 getViewer: (input) => {
2131 viewers.push(input.host);
2132 assert.strictEqual(input.host, "code.example:3000");
2133 return Effect.succeed("bilal");
2134 },
2135 listChangeRequests: (input) => {
2136 assert.strictEqual(input.host, "code.example:3000");
2137 return Effect.succeed({ items: [], truncated: false, continues: true });
2138 },
2139 getChangeRequest: (input) => {
2140 assert.strictEqual(input.host, "code.example:3000");
2141 return Effect.succeed({ ...hostedChangeRequest("Forgejo detail"), number: 42 });
2142 },
2143 getChangeRequestSummary: (input) =>
2144 Effect.sync(() => {
2145 seen.push(input.host);
2146 return changeRequest(42, "2026-07-02T00:00:00Z");
2147 }),
2148 }),
2149 ],
2150 resolveHandle: ({ context }) => {
2151 if (context?.requestedHost === undefined) {
2152 return Effect.succeed({ context: context!, provider: undefined as never });
2153 }
2154 assert.strictEqual(context.requestedHost, "code.example:3000");
2155 return Effect.succeed({
2156 context: {
2157 ...context,
2158 provider: {
2159 kind: SourceControlProviderKind.make("forgejo"),
2160 name: "Forgejo",
2161 baseUrl: "http://code.example:3000",
2162 },
2163 },
2164 provider: undefined as never,
2165 });
2166 },
2167 });
2168 yield* service.summary(
2169 {
2170 projectId: "ssh" as ProjectId,
2171 host: "code.example:3000",
2172 repository: "team/repo",
2173 number: 42,
2174 },
2175 { recoverTransientFailure: false },
2176 );
2177 assert.deepStrictEqual(seen, ["code.example:3000"]);
2178 const listed = yield* service.list({
2179 projectId: "ssh" as ProjectId,
2180 host: "code.example:3000",
2181 state: "open",
2182 });
2183 assert.strictEqual(listed.viewers["code.example:3000"], "bilal");
2184 const preview = yield* service.preview({
2185 projectId: "ssh" as ProjectId,
2186 host: "code.example:3000",
2187 repository: "team/repo",
2188 number: 42,
2189 });
2190 assert.strictEqual(preview.number, 42);
2191 const detail = yield* service.detail({
2192 projectId: "ssh" as ProjectId,
2193 host: "code.example:3000",
2194 repository: "team/repo",
2195 number: 42,
2196 });
2197 assert.strictEqual(detail.body, "Forgejo detail");
2198 assert.deepStrictEqual(viewers, ["code.example:3000"]);
2199 }
2200 }),
2201 );
2202
2203 it.effect("names an SSH remote's web host from a later checkout when the first cannot", () =>
2204 Effect.gen(function* () {
2205 const hosts: Array<string> = [];
2206 const service = yield* makeService({
2207 projects: ["/first", "/second"].map((workspaceRoot, index) =>
2208 project({
2209 id: `p${index}`,
2210 title: `checkout ${index}`,
2211 workspaceRoot,
2212 repository: "team/repo",
2213 provider: SourceControlProviderKind.make("forgejo"),
2214 host: "ssh.code.example",
2215 remoteUrl: "git@ssh.code.example:team/repo.git",
2216 }),
2217 ),
2218 providers: [
2219 fakePullRequestProvider(SourceControlProviderKind.make("forgejo"), {
2220 listChangeRequests: (input) => {
2221 hosts.push(input.host);
2222 return Effect.succeed({ items: [], truncated: false, continues: true });
2223 },
2224 }),
2225 ],
2226 resolveHandle: ({ cwd, context }) =>
2227 Effect.succeed({
2228 context:
2229 cwd === "/first"
2230 ? context!
2231 : {
2232 ...context!,
2233 provider: {
2234 kind: SourceControlProviderKind.make("forgejo"),
2235 name: "Forgejo",
2236 baseUrl: "http://code.example:3000",
2237 },
2238 },
2239 provider: undefined as never,
2240 }),
2241 });
2242
2243 yield* service.list({ state: "open" });
2244
2245 assert.deepStrictEqual(hosts, ["code.example:3000"]);
2246 }),
2247 );
2248
2249 it.effect("rejects a different Forgejo HTTP port for an HTTP checkout", () =>
2250 Effect.gen(function* () {
2251 const service = yield* makeService({
2252 projects: [
2253 project({
2254 id: "http",
2255 title: "http",
2256 workspaceRoot: "/http",
2257 repository: "team/repo",
2258 provider: SourceControlProviderKind.make("forgejo"),
2259 host: "code.example",
2260 remoteUrl: "http://code.example:4000/team/repo.git",
2261 }),
2262 ],
2263 providers: [fakePullRequestProvider(SourceControlProviderKind.make("forgejo"))],
2264 });
2265 const failure = yield* service
2266 .summary(
2267 {
2268 projectId: "http" as ProjectId,
2269 host: "code.example:3000",
2270 repository: "team/repo",
2271 number: 42,
2272 },
2273 { recoverTransientFailure: false },
2274 )
2275 .pipe(Effect.flip);
2276 assert.strictEqual(failure._tag, "PullRequestUnavailableError");
2277 }),
2278 );
2279
2280 it.effect("resolves a project's repository identity when its shell has none cached", () =>
2281 Effect.gen(function* () {
2282 const resolved = project({
2283 id: "web",
2284 title: "web",
2285 workspaceRoot: "/web",
2286 repository: "acme/web",
2287 });
2288 const service = yield* makeService({
2289 projects: [{ ...resolved, repositoryIdentity: null }],
2290 providers: [
2291 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2292 getChangeRequestSummary: () => Effect.succeed(changeRequest(7, "2026-07-02T00:00:00Z")),
2293 }),
2294 ],
2295 resolveRepositoryIdentity: () => Effect.succeed(resolved.repositoryIdentity ?? null),
2296 });
2297
2298 const summary = yield* service.summary(
2299 { projectId: "web" as ProjectId, host: "github.com", repository: "acme/web", number: 7 },
2300 { recoverTransientFailure: false },
2301 );
2302
2303 assert.strictEqual(summary.number, 7);
2304 }),
2305 );
2306
2307 it.effect("routes a hosted reference to another repository through a project on that host", () =>
2308 Effect.gen(function* () {
2309 const seen: Array<{ cwd: string; repository: string; host: string }> = [];
2310 let projectReads = 0;
2311 const service = yield* makeService({
2312 onProjectRead: () => {
2313 projectReads += 1;
2314 },
2315 projects: [
2316 project({ id: "frontend", title: "web", workspaceRoot: "/web", repository: "acme/web" }),
2317 ],
2318 providers: [
2319 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2320 getChangeRequestSummary: (input) =>
2321 Effect.sync(() => {
2322 seen.push({ cwd: input.cwd, repository: input.repository, host: input.host });
2323 return changeRequest(7, "2026-07-02T00:00:00Z");
2324 }),
2325 }),
2326 ],
2327 });
2328
2329 const summary = yield* service.summary(
2330 { projectId: "frontend" as ProjectId, host: "github.com", repository: "acme/api", number: 7 },
2331 { recoverTransientFailure: false },
2332 );
2333
2334 assert.strictEqual(summary.number, 7);
2335 assert.deepStrictEqual(seen, [{ cwd: "/web", repository: "acme/api", host: "github.com" }]);
2336
2337 // A sync sweep resolves the project once for all of its references, then reads fresh again.
2338 const readsPerReference = projectReads;
2339 const read = (number: number) =>
2340 service.summary(
2341 { projectId: "frontend" as ProjectId, host: "github.com", repository: "acme/api", number },
2342 { recoverTransientFailure: false },
2343 );
2344 assert.isAbove(readsPerReference, 2);
2345 yield* service.withSharedProjectReads(Effect.all([read(8), read(9), read(10)]));
2346 // One read of the project and one of the host's projects, for all three references.
2347 assert.strictEqual(projectReads, readsPerReference + 2);
2348 yield* read(11);
2349 assert.strictEqual(projectReads, readsPerReference * 2 + 2);
2350 }),
2351 );
2352
2353 it.effect("an uncached summary reaches the host despite a cached read in another project", () =>
2354 Effect.gen(function* () {
2355 const caller = project({
2356 id: "caller",
2357 title: "caller",
2358 workspaceRoot: "/caller",
2359 repository: "acme/other",
2360 });
2361 const target = project({
2362 id: "gitlab",
2363 title: "gitlab",
2364 workspaceRoot: "/gitlab",
2365 repository: "team/project",
2366 provider: "gitlab",
2367 });
2368 let missing = false;
2369 let reads = 0;
2370 const service = yield* makeService({
2371 projects: [caller, target],
2372 providers: [
2373 fakePullRequestProvider(SourceControlProviderKind.make("github")),
2374 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
2375 getChangeRequestSummary: (input) =>
2376 Effect.suspend(() => {
2377 reads++;
2378 assert.strictEqual(input.cwd, target.workspaceRoot);
2379 assert.strictEqual(input.repository, "team/project");
2380 assert.strictEqual(input.host, "gitlab.com");
2381 return missing
2382 ? Effect.fail(
2383 new PullRequestProviderError({
2384 provider: SourceControlProviderKind.make("gitlab"),
2385 operation: "summary",
2386 reason: "missing-tool",
2387 detail: "The hosting CLI is unavailable.",
2388 }),
2389 )
2390 : Effect.succeed(changeRequest(42, "2026-07-02T00:00:00Z"));
2391 }),
2392 }),
2393 ],
2394 });
2395 const reference = {
2396 projectId: caller.id,
2397 host: "gitlab.com",
2398 repository: "team/project",
2399 number: 42,
2400 allowStale: false,
2401 };
2402 yield* service.summary(reference, { recoverTransientFailure: false });
2403 missing = true;
2404 yield* service.summary(reference, { recoverTransientFailure: false });
2405 assert.strictEqual(reads, 1);
2406
2407 const error = yield* service
2408 .summary(reference, { recoverTransientFailure: false, bypassCache: true })
2409 .pipe(Effect.flip);
2410 expect(error).toMatchObject({
2411 _tag: "PullRequestUnavailableError",
2412 reason: "cli-missing",
2413 provider: "gitlab",
2414 });
2415 assert.strictEqual(reads, 2);
2416 }),
2417 );
2418
2419 it.effect("routes Azure reads and writes through the requested organization's checkout", () =>
2420 Effect.gen(function* () {
2421 const seen: string[] = [];
2422 const service = yield* makeService({
2423 projects: ["org-a", "org-b"].map((organization) =>
2424 project({
2425 id: organization,
2426 title: organization,
2427 workspaceRoot: `/${organization}`,
2428 repository: `${organization}/project/_git/web`,
2429 provider: SourceControlProviderKind.make("azure-devops"),
2430 host: "dev.azure.com",
2431 }),
2432 ),
2433 providers: [
2434 fakePullRequestProvider(SourceControlProviderKind.make("azure-devops"), {
2435 ...keyedByCanonicalKey,
2436 getChangeRequestSummary: (input) =>
2437 Effect.sync(() => {
2438 seen.push(`read ${input.cwd} ${input.repository}`);
2439 return changeRequest(7, "2026-07-02T00:00:00Z");
2440 }),
2441 runAction: (input) =>
2442 Effect.sync(() => {
2443 seen.push(`write ${input.cwd} ${input.repository}`);
2444 }),
2445 }),
2446 ],
2447 });
2448 const reference = {
2449 projectId: "org-a" as ProjectId,
2450 host: "dev.azure.com",
2451 repository: "org-b/project/_git/web",
2452 number: 7,
2453 };
2454 yield* service.summary(reference, { recoverTransientFailure: false });
2455 yield* service.runAction({ ...reference, action: "merge" });
2456 assert.deepStrictEqual(seen, ["read /org-b web", "write /org-b web", "read /org-b web"]);
2457 }),
2458 );
2459
2460 it.effect.each([
2461 {
2462 host: "ssh.dev.azure.com",
2463 repository: "v3/org-b/project/web",
2464 remoteUrl: "git@ssh.dev.azure.com:v3/org-b/project/web",
2465 },
2466 {
2467 host: "vs-ssh.visualstudio.com",
2468 repository: "v3/org-b/project/web",
2469 remoteUrl: "git@vs-ssh.visualstudio.com:v3/org-b/project/web",
2470 },
2471 {
2472 host: "org-b.visualstudio.com",
2473 repository: "DefaultCollection/project/_git/web",
2474 remoteUrl: "https://org-b.visualstudio.com/DefaultCollection/project/_git/web",
2475 },
2476 ])("routes Azure URL reads and writes through a $host checkout", (checkout) =>
2477 Effect.gen(function* () {
2478 const seen: string[] = [];
2479 const target = project({
2480 id: "target",
2481 title: "target",
2482 workspaceRoot: "/target",
2483 provider: SourceControlProviderKind.make("azure-devops"),
2484 ...checkout,
2485 });
2486 const service = yield* makeService({
2487 projects: [
2488 ...["org-a/project/_git/web", "org-b/other-project/_git/web"].map((repository) =>
2489 project({
2490 id: repository,
2491 title: repository,
2492 workspaceRoot: `/${repository}`,
2493 provider: SourceControlProviderKind.make("azure-devops"),
2494 host: "dev.azure.com",
2495 repository,
2496 }),
2497 ),
2498 target,
2499 ],
2500 providers: [
2501 fakePullRequestProvider(SourceControlProviderKind.make("azure-devops"), {
2502 ...keyedByCanonicalKey,
2503 getChangeRequestSummary: (input) =>
2504 Effect.sync(() => {
2505 seen.push(`read ${input.cwd} ${input.repository}`);
2506 return changeRequest(7, "2026-07-02T00:00:00Z");
2507 }),
2508 runAction: (input) =>
2509 Effect.sync(() => {
2510 seen.push(`write ${input.cwd} ${input.repository}`);
2511 }),
2512 }),
2513 ],
2514 });
2515 const reference = {
2516 projectId: "org-a/project/_git/web" as ProjectId,
2517 host: "dev.azure.com",
2518 repository: "org-b/project/_git/web",
2519 number: 7,
2520 };
2521 yield* service.summary(reference, { recoverTransientFailure: false });
2522 yield* service.runAction({ ...reference, action: "merge" });
2523 assert.deepStrictEqual(seen, ["read /target web", "write /target web", "read /target web"]);
2524 }),
2525 );
2526
2527 it.effect.each([
2528 { case: "another organization", repository: "org-b/project/_git/web" },
2529 { case: "a sibling repository", repository: "org-a/project/_git/web-e2e" },
2530 ])("refuses Azure reads and writes in $case without its checkout", ({ repository }) =>
2531 Effect.gen(function* () {
2532 const service = yield* makeService({
2533 projects: [
2534 project({
2535 id: "org-a",
2536 title: "org-a",
2537 workspaceRoot: "/org-a",
2538 repository: "org-a/project/_git/web",
2539 provider: SourceControlProviderKind.make("azure-devops"),
2540 host: "dev.azure.com",
2541 }),
2542 ],
2543 providers: [
2544 fakePullRequestProvider(SourceControlProviderKind.make("azure-devops"), {
2545 ...keyedByCanonicalKey,
2546 getChangeRequestSummary: () => Effect.die("must not read the wrong organization"),
2547 runAction: () => Effect.die("must not modify the wrong organization"),
2548 }),
2549 ],
2550 });
2551 const reference = {
2552 projectId: "org-a" as ProjectId,
2553 host: "dev.azure.com",
2554 repository,
2555 number: 7,
2556 };
2557 const readError = yield* Effect.flip(
2558 service.summary(reference, { recoverTransientFailure: false }),
2559 );
2560 const writeError = yield* Effect.flip(service.runAction({ ...reference, action: "close" }));
2561 for (const error of [readError, writeError]) {
2562 expect(error).toMatchObject({
2563 _tag: "PullRequestUnavailableError",
2564 reason: "repository-without-project",
2565 message: `${repository} is not a project in T3 Code. Add it as a project to read its change requests.`,
2566 });
2567 }
2568 }),
2569 );
2570
2571 // regression: #37633 any checkout on the host routes the read, so name the host, not the repository
2572 it.effect("names the host when no project has a checkout on it for a host-routed read", () =>
2573 Effect.gen(function* () {
2574 const service = yield* makeService({
2575 projects: [project({ id: "wrapper", title: "Wrapper", workspaceRoot: "/work" })],
2576 providers: [
2577 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
2578 getChangeRequestSummary: () => Effect.die("no checkout to read through"),
2579 }),
2580 ],
2581 });
2582 const error = yield* Effect.flip(
2583 service.summary(
2584 {
2585 projectId: "wrapper" as ProjectId,
2586 host: "gitlab.com",
2587 repository: "acme/web",
2588 number: 7,
2589 },
2590 { recoverTransientFailure: false },
2591 ),
2592 );
2593 assert.strictEqual(error._tag, "PullRequestUnavailableError");
2594 expect(error.message).not.toContain("acme/web is not a project");
2595 expect(error.message).toContain("gitlab.com");
2596 }),
2597 );
2598
2599 it.effect("prefers a matching checkout over a non-repository project's directory", () =>
2600 Effect.gen(function* () {
2601 const seen: string[] = [];
2602 const service = yield* makeService({
2603 projects: [
2604 project({ id: "inbox", title: "Inbox", workspaceRoot: "/home/alex" }),
2605 project({ id: "repo", title: "API", workspaceRoot: "/api", repository: "acme/api" }),
2606 ],
2607 providers: [
2608 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2609 getChangeRequestSummary: (input) =>
2610 Effect.sync(() => {
2611 seen.push(input.cwd);
2612 return changeRequest(7, "2026-07-02T00:00:00Z");
2613 }),
2614 }),
2615 ],
2616 });
2617 yield* service.summary(
2618 {
2619 projectId: "inbox" as ProjectId,
2620 host: "github.com",
2621 repository: "acme/api",
2622 number: 7,
2623 },
2624 { recoverTransientFailure: false },
2625 );
2626 assert.deepStrictEqual(seen, ["/api"]);
2627 }),
2628 );
2629
2630 // regression: #17167 refresh linked PRs without a checkout
2631 it.effect("requires an explicit host for a non-repository project's linked PR", () =>
2632 Effect.gen(function* () {
2633 const service = yield* makeService({
2634 projects: [project({ id: "inbox", title: "Inbox", workspaceRoot: "/home/alex" })],
2635 providers: [fakePullRequestProvider(SourceControlProviderKind.make("github"))],
2636 });
2637 const error = yield* service
2638 .summary(
2639 {
2640 projectId: "inbox" as ProjectId,
2641 repository: "acme/api",
2642 number: 7,
2643 },
2644 { recoverTransientFailure: false },
2645 )
2646 .pipe(Effect.flip);
2647 assert.strictEqual(error._tag, "PullRequestUnavailableError");
2648 }),
2649 );
2650
2651 it.effect("refuses a review request this viewer may not make, and says what access it takes", () =>
2652 Effect.gen(function* () {
2653 let sent = false;
2654 const service = yield* makeService({
2655 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
2656 providers: [
2657 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2658 getViewerPermissions: () =>
2659 Effect.succeed({
2660 actions: ["ready", "draft", "close", "reopen"],
2661 comment: true,
2662 resolve: true,
2663 verdicts: ["comment", "approve", "request-changes"],
2664 requestReviewers: false,
2665 }),
2666 setReviewerRequest: () => {
2667 sent = true;
2668 return Effect.void;
2669 },
2670 }),
2671 ],
2672 });
2673
2674 const error = yield* Effect.flip(
2675 service.requestReviewers({
2676 projectId: "p1" as ProjectId,
2677 repository: "acme/web",
2678 number: 1,
2679 reviewers: [{ id: "octocat", kind: "user" }],
2680 requested: true,
2681 }),
2682 );
2683
2684 assert.strictEqual(error._tag, "PullRequestOperationError");
2685 assert.include(error.message, "You need write access on this repository to ask for a review.");
2686 assert.isFalse(sent);
2687 }),
2688 );
2689
2690 it.effect.each(["list", "listStats"] as const)(
2691 "retries a replacement %s read that joins a canceled lookup",
2692 (operation) =>
2693 Effect.gen(function* () {
2694 const started = yield* Deferred.make<void>();
2695 const stopping = yield* Deferred.make<void>();
2696 const finishShutdown = yield* Deferred.make<void>();
2697 let hostCalls = 0;
2698 const lookup = Effect.gen(function* () {
2699 if (++hostCalls !== 1) return;
2700 yield* Deferred.succeed(started, undefined);
2701 return yield* Effect.never.pipe(
2702 Effect.onInterrupt(() =>
2703 Deferred.succeed(stopping, undefined).pipe(
2704 Effect.andThen(Deferred.await(finishShutdown)),
2705 ),
2706 ),
2707 );
2708 });
2709 const service = yield* makeService({
2710 projects: [
2711 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
2712 ],
2713 providers: [
2714 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2715 listChangeRequests: () =>
2716 lookup.pipe(
2717 Effect.as({
2718 items: [changeRequest(1, "2026-07-02T00:00:00Z")],
2719 truncated: false,
2720 continues: false,
2721 }),
2722 ),
2723 listChangeRequestStats: () =>
2724 lookup.pipe(
2725 Effect.as([{ repository: "acme/web", number: 1, additions: 3, deletions: 1 }]),
2726 ),
2727 }),
2728 ],
2729 });
2730 const read =
2731 operation === "list"
2732 ? service
2733 .list({ state: "open" })
2734 .pipe(Effect.map((result) => result.entries.map((entry) => entry.number)))
2735 : service
2736 .listStats({
2737 refs: [{ projectId: "p1" as ProjectId, repository: "acme/web", number: 1 }],
2738 })
2739 .pipe(Effect.map((result) => result.stats.map((stat) => stat.number)));
2740 const original = yield* Effect.forkScoped(read);
2741 yield* Deferred.await(started);
2742 const cancellation = yield* Effect.forkScoped(Fiber.interrupt(original));
2743 yield* Deferred.await(stopping);
2744 const replacement = yield* Effect.forkScoped(read, { startImmediately: true });
2745 yield* Deferred.succeed(finishShutdown, undefined);
2746 yield* Fiber.join(cancellation);
2747 const canceled = yield* Fiber.await(original);
2748 assert.isTrue(Exit.isFailure(canceled));
2749 if (Exit.isFailure(canceled)) assert.isTrue(Cause.hasInterruptsOnly(canceled.cause));
2750 assert.deepStrictEqual(yield* Fiber.join(replacement), [1]);
2751 assert.strictEqual(hostCalls, 2);
2752 }),
2753 );
2754
2755 it.effect("shares one cold viewer lookup across distinct concurrent lists", () =>
2756 Effect.gen(function* () {
2757 let viewerCalls = 0;
2758 let listCalls = 0;
2759 const service = yield* makeService({
2760 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
2761 providers: [
2762 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2763 getViewer: () =>
2764 Effect.sync(() => {
2765 viewerCalls += 1;
2766 }).pipe(Effect.andThen(Effect.yieldNow), Effect.as("bilal")),
2767 listChangeRequests: () =>
2768 Effect.sync(() => {
2769 listCalls += 1;
2770 return { items: [], truncated: false, continues: true };
2771 }),
2772 }),
2773 ],
2774 });
2775
2776 yield* Effect.forEach(
2777 ["all", "authored", "reviewing"],
2778 (involvement) =>
2779 service.list({
2780 state: "open",
2781 involvement: involvement as "all" | "authored" | "reviewing",
2782 }),
2783 { concurrency: "unbounded" },
2784 );
2785
2786 assert.strictEqual(viewerCalls, 1);
2787 assert.strictEqual(listCalls, 3);
2788 }),
2789 );
2790
2791 it.effect("a listing narrowed to some projects is its own cache entry", () =>
2792 Effect.gen(function* () {
2793 const asked: ReadonlyArray<string>[] = [];
2794 const service = yield* makeService({
2795 projects: [
2796 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
2797 project({ id: "p2", title: "docs", workspaceRoot: "/b", repository: "acme/docs" }),
2798 ],
2799 providers: [
2800 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2801 listChangeRequestsAcross: (input) => {
2802 asked.push(input.repositories);
2803 return Effect.succeed({
2804 items: input.repositories.map((repository, index) =>
2805 batchedChangeRequest(index + 1, repository, "2026-07-02T00:00:00Z"),
2806 ),
2807 truncated: false,
2808 });
2809 },
2810 }),
2811 ],
2812 });
2813
2814 yield* service.list({ state: "open" });
2815 const narrowed = yield* service.list({ state: "open", projectIds: ["p2" as ProjectId] });
2816
2817 assert.deepStrictEqual(asked, [["acme/web", "acme/docs"], ["acme/docs"]]);
2818 assert.deepStrictEqual(
2819 narrowed.entries.map((entry) => entry.repository),
2820 ["acme/docs"],
2821 );
2822
2823 yield* service.list({ state: "open", projectIds: ["p2" as ProjectId] });
2824 assert.strictEqual(asked.length, 2);
2825 }),
2826 );
2827
2828 it.effect(
2829 "keeps listing freshness tied to read start when filtered reads finish out of order",
2830 () =>
2831 Effect.gen(function* () {
2832 const olderStarted = yield* Deferred.make<void>();
2833 const releaseOlder = yield* Deferred.make<void>();
2834 let reads = 0;
2835 const updatedAt = "2026-07-02T00:00:00Z";
2836 const service = yield* makeService({
2837 projects: [
2838 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
2839 ],
2840 providers: [
2841 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2842 listChangeRequests: ({ filters }) =>
2843 Effect.gen(function* () {
2844 reads += 1;
2845 const older = filters?.checks === "failing";
2846 if (older) {
2847 yield* Deferred.succeed(olderStarted, undefined);
2848 yield* Deferred.await(releaseOlder);
2849 }
2850 return {
2851 items: [
2852 {
2853 ...changeRequest(1, updatedAt),
2854 checksState: older ? ("failing" as const) : ("passing" as const),
2855 mergeability: older ? ("mergeable" as const) : ("conflicting" as const),
2856 },
2857 ],
2858 truncated: false,
2859 continues: false,
2860 };
2861 }),
2862 }),
2863 ],
2864 });
2865 const olderInput = { state: "open" as const, filters: { checks: "failing" as const } };
2866 const newerInput = { state: "open" as const, filters: { checks: "passing" as const } };
2867
2868 const olderRead = yield* service.list(olderInput).pipe(Effect.forkChild());
2869 yield* Deferred.await(olderStarted);
2870 yield* TestClock.adjust("1 second");
2871 const newer = yield* service.list(newerInput);
2872 yield* Deferred.succeed(releaseOlder, undefined);
2873 const older = yield* Fiber.join(olderRead);
2874
2875 assert.strictEqual(older.entries[0]?.checksState, "failing");
2876 assert.strictEqual(older.entries[0]?.mergeability, "mergeable");
2877 assert.strictEqual(newer.entries[0]?.checksState, "passing");
2878 assert.strictEqual(newer.entries[0]?.mergeability, "conflicting");
2879 assert.strictEqual(typeof older.entries[0]?.observedAt, "number");
2880 assert.strictEqual(typeof newer.entries[0]?.observedAt, "number");
2881 assert.isBelow(older.entries[0]!.observedAt!, newer.entries[0]!.observedAt!);
2882
2883 const cachedOlder = yield* service.list(olderInput);
2884 assert.strictEqual(cachedOlder.entries[0]?.observedAt, older.entries[0]?.observedAt);
2885 assert.strictEqual(reads, 2);
2886 }),
2887 );
2888
2889 it.effect("does not revive old summaries when project epochs are evicted", () =>
2890 Effect.gen(function* () {
2891 let title = "old";
2892 const service = yield* makeService({
2893 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
2894 providers: [
2895 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2896 getChangeRequest: () => Effect.succeed({ ...hostedChangeRequest("body"), title }),
2897 }),
2898 ],
2899 });
2900 const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
2901 assert.strictEqual((yield* service.summary(ref))?.title, "old");
2902 title = "new";
2903 yield* service.refreshAfterTurn(ref.projectId);
2904 assert.strictEqual((yield* service.summary(ref))?.title, "new");
2905 for (let index = 0; index < 2048; index++)
2906 yield* service.refreshAfterTurn(`project-${index}` as ProjectId);
2907 assert.strictEqual((yield* service.summary(ref))?.title, "new");
2908 }),
2909 );
2910
2911 it.effect("a finished turn leaves another project's cached listing in place", () =>
2912 Effect.gen(function* () {
2913 const reads: string[] = [];
2914 const service = yield* makeService({
2915 projects: [
2916 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
2917 project({ id: "p2", title: "api", workspaceRoot: "/b", repository: "acme/api" }),
2918 ],
2919 providers: [
2920 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
2921 listChangeRequests: ({ repository }) => {
2922 reads.push(repository);
2923 return Effect.succeed({ items: [], truncated: false, continues: false });
2924 },
2925 }),
2926 ],
2927 });
2928 const webListing = { state: "open" as const, projectId: "p1" as ProjectId };
2929 const everyListing = { state: "open" as const };
2930
2931 yield* service.list(webListing);
2932 yield* service.list(everyListing);
2933 reads.length = 0;
2934 yield* service.refreshAfterTurn("p2" as ProjectId);
2935 yield* service.list(webListing);
2936 yield* service.list(everyListing);
2937 assert.deepStrictEqual(reads, []);
2938
2939 yield* service.refreshAfterTurn("p2" as ProjectId, { pushed: true });
2940 yield* service.list(everyListing);
2941 assert.deepStrictEqual(reads.toSorted(), ["acme/api", "acme/web"]);
2942 }),
2943 );
2944
2945 it.effect("a refresh or a finished turn drops the provider's own change request reads", () =>
2946 Effect.gen(function* () {
2947 const forgotten: Array<{ readonly repository: string; readonly number?: number } | undefined> =
2948 [];
2949 const service = yield* makeService({
2950 projects: [
2951 project({
2952 id: "p1",
2953 title: "web",
2954 workspaceRoot: "/a",
2955 repository: "acme/web",
2956 provider: "gitlab",
2957 }),
2958 ],
2959 providers: [
2960 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
2961 forgetChangeRequestReads: (scope) => Effect.sync(() => void forgotten.push(scope)),
2962 }),
2963 ],
2964 });
2965 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
2966
2967 yield* service.invalidate({ reference });
2968 yield* service.refreshAfterTurn(reference.projectId);
2969 yield* service.invalidate({});
2970
2971 assert.deepStrictEqual(forgotten, [
2972 { repository: "acme/web", number: 1 },
2973 undefined,
2974 undefined,
2975 ]);
2976 }),
2977 );
2978
2979 it.effect("a read during a refresh cannot keep the provider's old change request", () =>
2980 Effect.gen(function* () {
2981 let hostTitle = "old";
2982 let held: string | undefined;
2983 let gate:
2984 | { readonly entered: Deferred.Deferred<void>; readonly release: Deferred.Deferred<void> }
2985 | undefined;
2986 const service = yield* makeService({
2987 projects: [
2988 project({
2989 id: "p1",
2990 title: "web",
2991 workspaceRoot: "/a",
2992 repository: "acme/web",
2993 provider: "gitlab",
2994 }),
2995 ],
2996 providers: [
2997 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
2998 getChangeRequest: () =>
2999 Effect.sync(() => {
3000 held ??= hostTitle;
3001 return { ...hostedChangeRequest("body"), title: held };
3002 }),
3003 forgetChangeRequestReads: () =>
3004 Effect.gen(function* () {
3005 if (gate !== undefined) {
3006 yield* Deferred.succeed(gate.entered, undefined);
3007 yield* Deferred.await(gate.release);
3008 }
3009 held = undefined;
3010 }),
3011 }),
3012 ],
3013 });
3014 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3015 const refreshWithReadInBetween = (refresh: Effect.Effect<void>) =>
3016 Effect.gen(function* () {
3017 gate = { entered: yield* Deferred.make<void>(), release: yield* Deferred.make<void>() };
3018 const running = yield* refresh.pipe(Effect.forkChild());
3019 yield* Deferred.await(gate.entered);
3020 yield* service.detail(reference);
3021 yield* Deferred.succeed(gate.release, undefined);
3022 yield* Fiber.join(running);
3023 gate = undefined;
3024 });
3025
3026 assert.strictEqual((yield* service.detail(reference)).title, "old");
3027 hostTitle = "after turn";
3028 yield* refreshWithReadInBetween(service.refreshAfterTurn(reference.projectId));
3029 assert.strictEqual((yield* service.detail(reference)).title, "after turn");
3030
3031 hostTitle = "after refresh";
3032 yield* refreshWithReadInBetween(service.invalidate({ reference }));
3033 assert.strictEqual((yield* service.detail(reference)).title, "after refresh");
3034 }),
3035 );
3036
3037 it.effect("close and reopen notify subscribed readers after invalidating their cached state", () =>
3038 Effect.gen(function* () {
3039 let hostCalls = 0;
3040 let state: "open" | "closed" = "open";
3041 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3042 const service = yield* makeService({
3043 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3044 providers: [
3045 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3046 getChangeRequestSummary: () =>
3047 Effect.succeed({ ...changeRequest(1, "2026-09-16T00:00:00.000Z"), state }),
3048 runAction: (input) =>
3049 Effect.sync(() => {
3050 state = input.action === "close" ? "closed" : "open";
3051 }),
3052 listChangeRequests: () => {
3053 hostCalls += 1;
3054 return Effect.succeed({ items: [], truncated: false, continues: false });
3055 },
3056 }),
3057 ],
3058 });
3059
3060 yield* service.refreshAfterTurn(reference.projectId);
3061 yield* service.list({ state: "open" });
3062 assert.strictEqual((yield* service.summary(reference)).state, "open");
3063 for (const action of ["close", "reopen"] as const) {
3064 const refreshed = yield* service.subscribeRefreshes.pipe(
3065 Stream.drop(1),
3066 Stream.take(1),
3067 Stream.mapEffect(() =>
3068 Effect.gen(function* () {
3069 yield* service.list({ state: "open" });
3070 return yield* service.summary(reference);
3071 }),
3072 ),
3073 Stream.runHead,
3074 Effect.forkChild({ startImmediately: true }),
3075 );
3076 yield* service.runAction({ ...reference, action });
3077 assert.strictEqual(
3078 Option.getOrThrow(yield* Fiber.join(refreshed)).state,
3079 action === "close" ? "closed" : "open",
3080 );
3081 }
3082 assert.strictEqual(hostCalls, 3);
3083 }),
3084 );
3085
3086 it.effect("reads a host's repositories in one search, and files the rows back under each", () =>
3087 Effect.gen(function* () {
3088 const asked: Array<ReadonlyArray<string>> = [];
3089 const separately: string[] = [];
3090 const service = yield* makeService({
3091 projects: [
3092 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
3093 project({ id: "p2", title: "web", workspaceRoot: "/b", repository: "acme/web" }),
3094 project({
3095 id: "p3",
3096 title: "on gitlab",
3097 workspaceRoot: "/c",
3098 repository: "group/project",
3099 provider: SourceControlProviderKind.make("gitlab"),
3100 }),
3101 ],
3102 providers: [
3103 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3104 listChangeRequests: ({ repository }) => {
3105 separately.push(repository);
3106 return Effect.succeed({ items: [], truncated: false, continues: true });
3107 },
3108 listChangeRequestsAcross: (input) => {
3109 asked.push(input.repositories);
3110 return Effect.succeed({
3111 items: [
3112 batchedChangeRequest(1, "acme/web", "2026-07-03T00:00:00Z"),
3113 batchedChangeRequest(2, "pingdotgg/t3code", "2026-07-02T00:00:00Z"),
3114 ],
3115 truncated: false,
3116 });
3117 },
3118 }),
3119 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
3120 listChangeRequests: ({ repository }) => {
3121 separately.push(repository);
3122 return Effect.succeed({
3123 items: [changeRequest(3, "2026-07-01T00:00:00Z")],
3124 truncated: false,
3125 continues: true,
3126 });
3127 },
3128 }),
3129 ],
3130 });
3131
3132 const result = yield* service.list({ state: "open" });
3133
3134 assert.deepStrictEqual(asked, [["pingdotgg/t3code", "acme/web"]]);
3135 assert.deepStrictEqual(separately, ["group/project"]);
3136 assert.deepStrictEqual(
3137 result.entries.map((entry) => [entry.projectId, entry.number]),
3138 [
3139 ["p2", 1],
3140 ["p1", 2],
3141 ["p3", 3],
3142 ],
3143 );
3144 }),
3145 );
3146 it.effect("carries every repository of a slice on from the oldest row in it", () =>
3147 Effect.gen(function* () {
3148 const service = yield* makeService({
3149 projects: [
3150 project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
3151 project({ id: "p2", title: "web", workspaceRoot: "/b", repository: "acme/web" }),
3152 project({ id: "p3", title: "docs", workspaceRoot: "/c", repository: "acme/docs" }),
3153 ],
3154 providers: [
3155 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3156 listChangeRequestsAcross: () =>
3157 Effect.succeed({
3158 items: [
3159 batchedChangeRequest(1, "acme/web", "2026-07-03T00:00:00Z"),
3160 batchedChangeRequest(2, "pingdotgg/t3code", "2026-07-02T00:00:00Z"),
3161 batchedChangeRequest(3, "acme/web", "2026-07-02T00:00:00Z"),
3162 ],
3163 truncated: true,
3164 unresolved: ["acme/docs"],
3165 }),
3166 }),
3167 ],
3168 });
3169
3170 const result = yield* service.list({ state: "open" });
3171
3172 assert.isTrue(result.truncated);
3173 assert.deepStrictEqual(result.nextCursors, {
3174 "github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|1|2",
3175 "github.com acme/web": "2026-07-02T00:00:00Z|2|3",
3176 });
3177 }),
3178 );
3179 it.effect("carries a slice on without sending the rows it already sent", () =>
3180 Effect.gen(function* () {
3181 const cursors: Array<unknown> = [];
3182 const service = yield* makeService({
3183 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3184 providers: [
3185 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3186 listChangeRequestsAcross: (input) => {
3187 cursors.push(input.cursor);
3188 return Effect.succeed({
3189 items: [
3190 batchedChangeRequest(3, "acme/web", "2026-07-02T00:00:00Z"),
3191 batchedChangeRequest(4, "acme/web", "2026-07-02T00:00:00Z"),
3192 ],
3193 truncated: true,
3194 });
3195 },
3196 }),
3197 ],
3198 });
3199
3200 const result = yield* service.list({
3201 state: "open",
3202 cursors: { "github.com acme/web": "2026-07-02T00:00:00Z|1|3" },
3203 });
3204
3205 assert.deepStrictEqual(cursors, [
3206 {
3207 updatedBefore: "2026-07-02T00:00:00Z",
3208 delivered: 1,
3209 seenAt: [{ repository: "acme/web", number: 3 }],
3210 },
3211 ]);
3212 assert.deepStrictEqual(
3213 result.entries.map((entry) => entry.number),
3214 [4],
3215 );
3216 assert.deepStrictEqual(result.nextCursors, {
3217 "github.com acme/web": "2026-07-02T00:00:00Z|2|3,4",
3218 });
3219 }),
3220 );
3221 it.effect("reads a workspace larger than one search in chunks, and merges them", () =>
3222 Effect.gen(function* () {
3223 const asked: Array<number> = [];
3224 const service = yield* makeService({
3225 projects: Array.from({ length: 101 }, (_, index) =>
3226 project({
3227 id: `p${index}`,
3228 title: `repo ${index}`,
3229 workspaceRoot: `/w${index}`,
3230 repository: `acme/repo${index}`,
3231 }),
3232 ),
3233 providers: [
3234 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3235 listChangeRequestsAcross: (input) => {
3236 asked.push(input.repositories.length);
3237 return Effect.succeed({
3238 items: input.repositories.map((repository, index) =>
3239 batchedChangeRequest(index + 1, repository, "2026-07-02T00:00:00Z"),
3240 ),
3241 truncated: false,
3242 });
3243 },
3244 }),
3245 ],
3246 });
3247
3248 const result = yield* service.list({ state: "open" });
3249
3250 assert.deepStrictEqual(asked, [100, 1]);
3251 assert.strictEqual(result.entries.length, 101);
3252 }),
3253 );
3254 it.effect("asks on its own for a repository a search could not vouch for", () =>
3255 Effect.gen(function* () {
3256 const separately: string[] = [];
3257 const service = yield* makeService({
3258 projects: [
3259 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
3260 project({ id: "p2", title: "docs", workspaceRoot: "/b", repository: "acme/docs" }),
3261 ],
3262 providers: [
3263 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3264 listChangeRequests: ({ repository }) => {
3265 separately.push(repository);
3266 return repository === "acme/docs"
3267 ? Effect.fail(requestFailed)
3268 : Effect.succeed({ items: [], truncated: false, continues: true });
3269 },
3270 listChangeRequestsAcross: () =>
3271 Effect.succeed({
3272 items: [batchedChangeRequest(1, "acme/web", "2026-07-03T00:00:00Z")],
3273 truncated: false,
3274 unresolved: ["acme/docs"],
3275 }),
3276 }),
3277 ],
3278 });
3279
3280 const result = yield* service.list({ state: "open" });
3281
3282 assert.deepStrictEqual(separately, ["acme/docs"]);
3283 assert.deepStrictEqual(result.errors, [
3284 {
3285 projectId: "p2" as ProjectId,
3286 projectTitle: "docs",
3287 message: "acme/docs could not be read.",
3288 },
3289 ]);
3290 assert.deepStrictEqual(
3291 result.entries.map((entry) => entry.number),
3292 [1],
3293 );
3294 }),
3295 );
3296 it.effect("believes a search's silence about a repository it vouches for", () =>
3297 Effect.gen(function* () {
3298 const separately: string[] = [];
3299 const service = yield* makeService({
3300 projects: [
3301 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
3302 project({ id: "p2", title: "docs", workspaceRoot: "/b", repository: "acme/docs" }),
3303 ],
3304 providers: [
3305 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3306 listChangeRequests: ({ repository }) => {
3307 separately.push(repository);
3308 return Effect.succeed({ items: [], truncated: false, continues: true });
3309 },
3310 listChangeRequestsAcross: () =>
3311 Effect.succeed({
3312 items: [batchedChangeRequest(1, "acme/web", "2026-07-03T00:00:00Z")],
3313 truncated: false,
3314 }),
3315 }),
3316 ],
3317 });
3318
3319 const result = yield* service.list({ state: "open" });
3320
3321 assert.deepStrictEqual(separately, []);
3322 assert.deepStrictEqual(
3323 result.entries.map((entry) => entry.number),
3324 [1],
3325 );
3326 }),
3327 );
3328 it.effect("fills in the line counts for the rows it is given", () =>
3329 Effect.gen(function* () {
3330 const asked: Array<unknown> = [];
3331 const service = yield* makeService({
3332 projects: [
3333 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
3334 project({
3335 id: "p2",
3336 title: "on gitlab",
3337 workspaceRoot: "/b",
3338 repository: "group/project",
3339 provider: SourceControlProviderKind.make("gitlab"),
3340 }),
3341 ],
3342 providers: [
3343 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3344 listChangeRequestStats: (input) => {
3345 asked.push(input.changeRequests);
3346 return Effect.succeed([
3347 { repository: "acme/web", number: 1, additions: 12, deletions: 3 },
3348 ]);
3349 },
3350 }),
3351 fakePullRequestProvider(SourceControlProviderKind.make("gitlab")),
3352 ],
3353 });
3354
3355 const result = yield* service.listStats({
3356 refs: [
3357 { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 },
3358 { projectId: "p1" as ProjectId, repository: "acme/web", number: 2 },
3359 { projectId: "p2" as ProjectId, repository: "group/project", number: 3 },
3360 { projectId: "p1" as ProjectId, repository: "evil/repo", number: 4 },
3361 ],
3362 });
3363
3364 assert.deepStrictEqual(asked, [
3365 [
3366 { repository: "acme/web", number: 1 },
3367 { repository: "acme/web", number: 2 },
3368 ],
3369 ]);
3370 assert.deepStrictEqual(result.stats, [
3371 {
3372 projectId: "p1" as ProjectId,
3373 repository: "acme/web",
3374 number: 1,
3375 additions: 12,
3376 deletions: 3,
3377 },
3378 ]);
3379 }),
3380 );
3381
3382 it.effect("reads the fresh diff when detail or summary discovers a changed revision", () =>
3383 Effect.gen(function* () {
3384 const summaryStarted = yield* Deferred.make<void>();
3385 const releaseSummary = yield* Deferred.make<void>();
3386 let revision = "2026-07-02T00:00:00Z";
3387 let patch = "old patch";
3388 let diffCalls = 0;
3389 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3390 const service = yield* makeService({
3391 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3392 providers: [
3393 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3394 getChangeRequest: () =>
3395 Effect.sync(() => ({ ...hostedChangeRequest("body"), updatedAt: revision })),
3396 getChangeRequestSummary: () =>
3397 Effect.gen(function* () {
3398 const result = changeRequest(1, revision);
3399 yield* Deferred.succeed(summaryStarted, undefined);
3400 yield* Deferred.await(releaseSummary);
3401 return result;
3402 }),
3403 getDiff: () =>
3404 Effect.sync(() => {
3405 diffCalls += 1;
3406 return { patch, truncated: false, nextCursor: null };
3407 }),
3408 }),
3409 ],
3410 });
3411
3412 const coldSummary = yield* service.summary(reference).pipe(Effect.forkChild());
3413 yield* Deferred.await(summaryStarted);
3414 yield* service.detail(reference);
3415 assert.strictEqual((yield* service.diff(reference)).patch, "old patch");
3416 revision = "2026-07-02T00:01:00Z";
3417 patch = "new patch";
3418 yield* TestClock.adjust("61 seconds");
3419 yield* service.detail(reference);
3420 yield* Effect.yieldNow;
3421 assert.strictEqual((yield* service.detail(reference)).updatedAt, revision);
3422 yield* Deferred.succeed(releaseSummary, undefined);
3423 yield* Fiber.join(coldSummary);
3424 yield* service.summary(reference, { recoverTransientFailure: false });
3425 assert.strictEqual((yield* service.diff(reference)).patch, "new patch");
3426 assert.strictEqual(diffCalls, 2);
3427
3428 revision = "2026-07-02T00:02:00Z";
3429 patch = "summary-discovered patch";
3430 yield* TestClock.adjust("61 seconds");
3431 yield* service.summary(reference, { recoverTransientFailure: false });
3432 assert.strictEqual((yield* service.diff(reference)).patch, patch);
3433 assert.strictEqual(diffCalls, 3);
3434 }),
3435 );
3436
3437 it.effect("keeps a withheld file's read out of the page's cached diff", () =>
3438 Effect.gen(function* () {
3439 const provider = fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3440 getDiff: (input) =>
3441 Effect.succeed({
3442 patch: input.path === undefined ? "page" : `file ${input.path}`,
3443 truncated: input.path === undefined,
3444 nextCursor: null,
3445 }),
3446 });
3447 const service = yield* makeService({
3448 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3449 providers: [provider],
3450 });
3451 const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 10 };
3452 assert.strictEqual((yield* service.diff(ref)).patch, "page");
3453 assert.strictEqual(
3454 (yield* service.diff({ ...ref, path: "sdk.patch" })).patch,
3455 "file sdk.patch",
3456 );
3457 assert.strictEqual((yield* service.diff(ref)).patch, "page");
3458
3459 // A host that would answer with its whole diff must not be cached as one file's.
3460 const wholeDiffOnly = yield* makeService({
3461 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3462 providers: [
3463 { ...provider, capabilities: { ...provider.capabilities, withheldFileDiff: false } },
3464 ],
3465 });
3466 const error = yield* Effect.flip(wholeDiffOnly.diff({ ...ref, path: "sdk.patch" }));
3467 assert.strictEqual(error._tag, "PullRequestOperationError");
3468 }),
3469 );
3470
3471 it.effect("keeps routed reads separate when the GitHub account changes", () =>
3472 Effect.gen(function* () {
3473 for (const operation of ["summary", "detail", "checks", "diff", "filesViewed"] as const) {
3474 let failing = false;
3475 let calls = 0;
3476 const read = () =>
3477 Effect.suspend(() => {
3478 calls += 1;
3479 return failing
3480 ? Effect.fail(requestFailed)
3481 : Effect.succeed(hostedChangeRequest("account A content"));
3482 });
3483 const service = yield* makeService({
3484 projects: [
3485 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
3486 ],
3487 providers: [
3488 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3489 capabilities: {
3490 ...fakePullRequestProvider(SourceControlProviderKind.make("github")).capabilities,
3491 viewedFiles: "host",
3492 },
3493 getFilesViewed: () =>
3494 read().pipe(
3495 Effect.as({
3496 files: [{ path: "private.ts", state: "viewed" as const }],
3497 truncated: false,
3498 }),
3499 ),
3500 getChangeRequestSummary: read,
3501 getChangeRequestChecks: read,
3502 getChangeRequest: read,
3503 getDiff: () =>
3504 read().pipe(
3505 Effect.as({ patch: "private patch", truncated: false, nextCursor: null }),
3506 ),
3507 }),
3508 ],
3509 });
3510 const readOperation = (input: Parameters<typeof service.diff>[0]) =>
3511 // @effect-diagnostics-next-line unnecessaryEffectGen:off - the generator unifies the per-operation union of Effect types, which Effect.asVoid cannot infer through.
3512 Effect.gen(function* () {
3513 yield* service[operation](input);
3514 });
3515 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3516 yield* readOperation({ ...reference, expectedAccountId: "101" });
3517 failing = true;
3518
3519 for (const allowStale of [false, true]) {
3520 const error = yield* Effect.flip(
3521 readOperation({ ...reference, expectedAccountId: "202", allowStale }),
3522 );
3523 assert.strictEqual(error._tag, "PullRequestOperationError");
3524 }
3525 assert.strictEqual(calls, 3);
3526 }
3527 }),
3528 );
3529
3530 it.effect("isolates routed caches for two credentials belonging to the same account", () =>
3531 Effect.gen(function* () {
3532 for (const operation of [
3533 "summary",
3534 "detail",
3535 "checks",
3536 "diff",
3537 "preview",
3538 "filesViewed",
3539 ] as const) {
3540 let credential = "broad";
3541 let calls = 0;
3542 const read = () =>
3543 Effect.suspend(() => {
3544 calls += 1;
3545 return credential === "broad"
3546 ? Effect.succeed(hostedChangeRequest("private content"))
3547 : Effect.fail(requestFailed);
3548 });
3549 const service = yield* makeService({
3550 projects: [
3551 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
3552 ],
3553 providers: [
3554 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3555 capabilities: {
3556 ...fakePullRequestProvider(SourceControlProviderKind.make("github")).capabilities,
3557 viewedFiles: "host",
3558 },
3559 getFilesViewed: () =>
3560 read().pipe(
3561 Effect.as({
3562 files: [{ path: "private.ts", state: "viewed" as const }],
3563 truncated: false,
3564 }),
3565 ),
3566 withVerifiedCredential: (_, use) =>
3567 Effect.suspend(() =>
3568 use({
3569 accountId: "101",
3570 viewer: "octocat",
3571 credentialFingerprint: credential,
3572 }),
3573 ),
3574 getChangeRequest: read,
3575 getChangeRequestChecks: read,
3576 getChangeRequestSummary: read,
3577 getDiff: () =>
3578 read().pipe(
3579 Effect.as({ patch: "private patch", truncated: false, nextCursor: null }),
3580 ),
3581 getChangeRequestPreview: read,
3582 }),
3583 ],
3584 });
3585 const readOperation = (input: Parameters<typeof service.diff>[0]) =>
3586 // @effect-diagnostics-next-line unnecessaryEffectGen:off - the generator unifies the per-operation union of Effect types, which Effect.asVoid cannot infer through.
3587 Effect.gen(function* () {
3588 yield* service[operation](input);
3589 });
3590 const reference = {
3591 projectId: "p1" as ProjectId,
3592 repository: "acme/web",
3593 number: 1,
3594 host: "github.com",
3595 expectedAccountId: "101",
3596 };
3597 if (operation === "checks") {
3598 yield* service.withRoutingCredential(reference, service.detail(reference));
3599 }
3600 yield* service.withRoutingCredential(reference, readOperation(reference));
3601 credential = "restricted";
3602 for (const allowStale of [false, true]) {
3603 const error = yield* Effect.flip(
3604 service.withRoutingCredential(reference, readOperation({ ...reference, allowStale })),
3605 );
3606 assert.strictEqual(error._tag, "PullRequestOperationError");
3607 }
3608 assert.strictEqual(calls, 3);
3609 }
3610 }),
3611 );
3612
3613 it.effect("rejects mismatched routing credentials before use and preserves action errors", () =>
3614 Effect.gen(function* () {
3615 let operations = 0;
3616 const service = yield* makeService({
3617 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3618 providers: [
3619 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3620 getRoutingIdentity: () => Effect.succeed({ accountId: "101", viewer: "octocat" }),
3621 withVerifiedCredential: (_, use) =>
3622 use({
3623 accountId: "101",
3624 viewer: "octocat",
3625 credentialFingerprint: "credential-a",
3626 }),
3627 }),
3628 ],
3629 });
3630 const reference = {
3631 projectId: "p1" as ProjectId,
3632 repository: "acme/web",
3633 number: 1,
3634 host: "github.com",
3635 expectedAccountId: "202",
3636 };
3637 const actionError = new PullRequestOperationError({
3638 operation: "runAction",
3639 detail: "ambiguous",
3640 });
3641 const operation = Effect.sync(() => {
3642 operations += 1;
3643 }).pipe(Effect.andThen(Effect.fail(actionError)));
3644 const rejected = yield* Effect.flip(service.withRoutingCredential(reference, operation));
3645 assert.strictEqual(rejected._tag, "PullRequestOperationError");
3646 if (rejected._tag === "PullRequestOperationError")
3647 assert.strictEqual(rejected.operation, "routeIdentity");
3648 assert.strictEqual(operations, 0);
3649 assert.strictEqual(
3650 yield* Effect.flip(
3651 service.withRoutingCredential({ ...reference, expectedAccountId: "101" }, operation),
3652 ),
3653 actionError,
3654 );
3655 assert.strictEqual(operations, 1);
3656 assert.deepStrictEqual(yield* service.routingIdentity({ host: "github.com" }), {
3657 accountId: "101",
3658 viewer: "octocat",
3659 host: "github.com",
3660 provider: "github",
3661 });
3662 }),
3663 );
3664
3665 it.effect(
3666 "opening detail preserves enriched linked summaries and updates draft and diff fields",
3667 () =>
3668 Effect.gen(function* () {
3669 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3670 const service = yield* makeService({
3671 projects: [
3672 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
3673 ],
3674 providers: [
3675 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3676 getChangeRequestSummary: () =>
3677 Effect.succeed({
3678 ...changeRequest(1, "2026-07-02T00:00:00Z"),
3679 isDraft: true,
3680 rebaseRequired: false,
3681 reviewDecision: "approved",
3682 checksState: "passing",
3683 }),
3684 getChangeRequest: () =>
3685 Effect.succeed({
3686 ...hostedChangeRequest("body", 14),
3687 deletions: 3,
3688 changedFiles: 5,
3689 mergeability: "conflicting",
3690 rebaseRequired: true,
3691 }),
3692 }),
3693 ],
3694 });
3695 yield* service.summary(reference);
3696 const detail = yield* service.detail(reference);
3697 const summary = yield* service.summary(reference);
3698 assert.strictEqual(detail.rebaseRequired, true);
3699 assert.strictEqual(summary.rebaseRequired, true);
3700 assert.strictEqual(summary.isDraft, false);
3701 assert.deepStrictEqual(summary.author, detail.author);
3702 assert.strictEqual(summary.additions, 14);
3703 assert.strictEqual(summary.deletions, 3);
3704 assert.strictEqual(summary.changedFiles, 5);
3705 assert.strictEqual(summary.mergeability, "conflicting");
3706 assert.strictEqual(summary.reviewDecision, "approved");
3707 assert.strictEqual(summary.checksState, "passing");
3708 }),
3709 );
3710
3711 it.effect("preserves merge queue removal details from the provider", () =>
3712 Effect.gen(function* () {
3713 const removal = { id: "RMQE_1", removedAt: "2026-07-02T00:00:00Z", reason: "CI failed" };
3714 const service = yield* makeService({
3715 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3716 providers: [
3717 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3718 getChangeRequest: () =>
3719 Effect.succeed({ ...hostedChangeRequest("body"), mergeQueueRemoval: removal }),
3720 }),
3721 ],
3722 });
3723 const detail = yield* service.detail({
3724 projectId: "p1" as ProjectId,
3725 repository: "acme/web",
3726 number: 1,
3727 });
3728 assert.deepStrictEqual(detail.mergeQueueRemoval, removal);
3729 }),
3730 );
3731
3732 it.effect("notifies linked threads when detail changes draft status in either direction", () =>
3733 Effect.gen(function* () {
3734 let isDraft = true;
3735 let updatedAt = "2026-07-02T00:00:00Z";
3736 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3737 const service = yield* makeService({
3738 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3739 providers: [
3740 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3741 getChangeRequest: () =>
3742 Effect.sync(() => ({ ...hostedChangeRequest("body"), isDraft, updatedAt })),
3743 }),
3744 ],
3745 });
3746 const changes = yield* service.subscribeStateChanges;
3747 const read = () => service.detail({ ...reference, allowStale: false });
3748 yield* read();
3749 yield* read();
3750 isDraft = false;
3751 yield* service.invalidate({ reference });
3752 yield* read();
3753 yield* read();
3754 isDraft = true;
3755 yield* service.invalidate({ reference });
3756 yield* read();
3757
3758 isDraft = false;
3759 updatedAt = "2026-07-01T00:00:00Z";
3760 yield* service.invalidate({ reference });
3761 yield* read();
3762
3763 // A different PR ends collection after all the synchronous notifications above.
3764 yield* service.reportState({ reference: { ...reference, number: 2 }, state: "open" });
3765 const events = yield* Stream.runCollect(
3766 changes.pipe(Stream.takeUntil((event) => event.number === 2, { excludeLast: true })),
3767 );
3768 assert.deepStrictEqual(events, [
3769 { host: "github.com", repository: "acme/web", number: 1 },
3770 { host: "github.com", repository: "acme/web", number: 1 },
3771 { host: "github.com", repository: "acme/web", number: 1 },
3772 ]);
3773 }),
3774 );
3775
3776 it.effect("deduplicates routed PR reports without dropping draft changes", () =>
3777 Effect.gen(function* () {
3778 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3779 const service = yield* makeService({
3780 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3781 providers: [fakePullRequestProvider(SourceControlProviderKind.make("github"))],
3782 });
3783 const changes = yield* service.subscribeStateChanges;
3784 for (const isDraft of [true, true, false, false, true]) {
3785 yield* service.reportState({ reference, state: "open", isDraft });
3786 }
3787 yield* service.reportState({ reference, state: "open" });
3788 yield* service.reportState({ reference, state: "open" });
3789 yield* service.reportState({ reference: { ...reference, number: 2 }, state: "open" });
3790 const events = yield* Stream.runCollect(
3791 changes.pipe(Stream.takeUntil((event) => event.number === 2, { excludeLast: true })),
3792 );
3793 assert.deepStrictEqual(
3794 events.map((event) => event.number),
3795 [1, 1, 1, 1],
3796 );
3797 }),
3798 );
3799
3800 it.effect.each(["github", "azure-devops"])(
3801 "reuses fresh %s detail checks without extending their refresh interval on detail cache hits",
3802 (provider) =>
3803 Effect.gen(function* () {
3804 let reads = 0;
3805 const repository = provider === "azure-devops" ? "web" : "acme/web";
3806 const reference = { projectId: "p1" as ProjectId, repository, number: 1 };
3807 const service = yield* makeService({
3808 projects: [
3809 project({
3810 id: "p1",
3811 title: "web",
3812 workspaceRoot: "/a",
3813 repository,
3814 provider,
3815 ...(provider === "azure-devops" ? { host: "dev.azure.com" } : {}),
3816 }),
3817 ],
3818 providers: [
3819 fakePullRequestProvider(SourceControlProviderKind.make(provider), {
3820 getChangeRequest: () =>
3821 Effect.succeed({
3822 ...hostedChangeRequest("Description"),
3823 checks: [{ name: "build", status: "success", description: null, url: null }],
3824 }),
3825 getChangeRequestChecks: () =>
3826 Effect.sync(() => {
3827 reads += 1;
3828 return { state: "closed" as const, checks: [] };
3829 }),
3830 }),
3831 ],
3832 });
3833 yield* TestClock.setTime(1_000);
3834 const detail = yield* service.detail(reference);
3835 expect(yield* service.checks(reference)).toEqual({
3836 state: detail.state,
3837 checks: detail.checks,
3838 observedAt: detail.observedAt,
3839 });
3840 expect(reads).toBe(0);
3841 yield* TestClock.adjust("16 seconds");
3842 yield* service.detail(reference);
3843 expect(yield* service.checks(reference)).toMatchObject({
3844 state: "closed",
3845 observedAt: 17_000,
3846 });
3847 expect(reads).toBe(1);
3848 yield* service.detail(reference);
3849 expect((yield* service.checks(reference))?.state).toBe("closed");
3850 expect(reads).toBe(1);
3851 }),
3852 );
3853
3854 it.effect("asks Azure for checks when its detail came back with none", () =>
3855 Effect.gen(function* () {
3856 let reads = 0;
3857 const reference = { projectId: "p1" as ProjectId, repository: "web", number: 1 };
3858 const service = yield* makeService({
3859 projects: [
3860 project({
3861 id: "p1",
3862 title: "web",
3863 workspaceRoot: "/a",
3864 repository: "web",
3865 provider: "azure-devops",
3866 }),
3867 ],
3868 providers: [
3869 fakePullRequestProvider(SourceControlProviderKind.make("azure-devops"), {
3870 getChangeRequest: () => Effect.succeed(hostedChangeRequest("Description")),
3871 getChangeRequestChecks: () =>
3872 Effect.sync(() => {
3873 reads += 1;
3874 return { state: "open" as const, checks: [] };
3875 }),
3876 }),
3877 ],
3878 });
3879 yield* service.detail(reference);
3880 yield* service.checks(reference);
3881 expect(reads).toBe(1);
3882 }),
3883 );
3884
3885 it.effect("preserves check observation time on cache hits and advances it on refresh", () =>
3886 Effect.gen(function* () {
3887 let reads = 0;
3888 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3889 const service = yield* makeService({
3890 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3891 providers: [
3892 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3893 getChangeRequestChecks: () =>
3894 Effect.sync(() => {
3895 reads += 1;
3896 return { state: "open" as const, checks: [] };
3897 }),
3898 }),
3899 ],
3900 });
3901 yield* TestClock.setTime(1_000);
3902 const first = yield* service.checks(reference);
3903 expect(first).toMatchObject({ observedAt: 1_000 });
3904 yield* TestClock.adjust("1 second");
3905 expect(yield* service.checks(reference)).toEqual(first);
3906 expect(reads).toBe(1);
3907 yield* TestClock.adjust("15 seconds");
3908 expect(yield* service.checks(reference)).toMatchObject({ observedAt: 17_000 });
3909 expect(reads).toBe(2);
3910 }),
3911 );
3912
3913 it.effect("reuses an observed merged state for strict settlement reads", () =>
3914 Effect.gen(function* () {
3915 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3916 const service = yield* makeService({
3917 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3918 providers: [
3919 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3920 getChangeRequest: () =>
3921 Effect.succeed({
3922 ...hostedChangeRequest("merged body", 4),
3923 state: "merged",
3924 updatedAt: "2026-07-03T00:00:00Z",
3925 }),
3926 getChangeRequestSummary: () => Effect.die("strict merged state must not refresh"),
3927 }),
3928 ],
3929 });
3930
3931 yield* service.detail(reference);
3932
3933 const summary = yield* service.summary(reference, { recoverTransientFailure: false });
3934 assert.strictEqual(summary.state, "merged");
3935 assert.strictEqual(summary.updatedAt, "2026-07-03T00:00:00Z");
3936 }),
3937 );
3938
3939 it.effect("does not let a stale detail reopen overwrite a fresher linked summary", () =>
3940 Effect.gen(function* () {
3941 const gate = yield* Deferred.make<void>();
3942 let detailCalls = 0;
3943 let summaryTitle = "old title";
3944 let summaryState: "open" | "merged" = "open";
3945 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
3946 const service = yield* makeService({
3947 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
3948 providers: [
3949 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
3950 getChangeRequest: () =>
3951 Effect.gen(function* () {
3952 detailCalls += 1;
3953 if (detailCalls > 1) yield* Deferred.await(gate);
3954 return hostedChangeRequest("old body", 4);
3955 }),
3956 getChangeRequestSummary: () =>
3957 Effect.succeed({
3958 ...changeRequest(1, "2026-07-02T00:00:00Z"),
3959 title: summaryTitle,
3960 state: summaryState,
3961 }),
3962 }),
3963 ],
3964 });
3965
3966 const first = yield* service.detail(reference);
3967 assert.strictEqual(first.title, "Change request 1");
3968
3969 summaryTitle = "merged title";
3970 summaryState = "merged";
3971 yield* TestClock.adjust("61 seconds");
3972 const settled = yield* service.summary(reference, { recoverTransientFailure: false });
3973 assert.strictEqual(settled.title, "merged title");
3974 assert.strictEqual(settled.state, "merged");
3975
3976 yield* TestClock.adjust("16 seconds");
3977 const stale = yield* service.detail(reference);
3978 assert.strictEqual(stale.title, "Change request 1");
3979 yield* Effect.yieldNow;
3980
3981 const display = yield* service.summary(reference);
3982 assert.strictEqual(display.title, "merged title");
3983 assert.strictEqual(display.state, "merged");
3984 assert.strictEqual(detailCalls, 2);
3985
3986 summaryTitle = "updated after merge";
3987 yield* TestClock.adjust("61 seconds");
3988 assert.strictEqual((yield* service.summary(reference)).title, "merged title");
3989 const refreshed = yield* service.summary({ ...reference, allowStale: false });
3990 assert.strictEqual(refreshed.title, "updated after merge");
3991 assert.strictEqual(refreshed.state, "merged");
3992 }),
3993 );
3994
3995 it.effect("keeps a row of a host that ignored the filters if any name of a label group holds", () =>
3996 Effect.gen(function* () {
3997 const sized = (number: number, updatedAt: string, ...names: ReadonlyArray<string>) => ({
3998 ...changeRequest(number, updatedAt),
3999 labels: names.map((name) => ({ name, color: null })),
4000 });
4001 const service = yield* makeService({
4002 projects: [
4003 project({
4004 id: "p1",
4005 title: "web",
4006 workspaceRoot: "/a",
4007 repository: "acme/web",
4008 provider: SourceControlProviderKind.make("gitlab"),
4009 }),
4010 ],
4011 providers: [
4012 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
4013 listChangeRequests: () =>
4014 Effect.succeed({
4015 items: [
4016 sized(1, "2026-07-04T00:00:00Z", "size:S", "bug"),
4017 sized(2, "2026-07-03T00:00:00Z", "size:XS", "bug"),
4018 sized(3, "2026-07-02T00:00:00Z", "size:L", "bug"),
4019 sized(4, "2026-07-01T00:00:00Z", "size:S"),
4020 ],
4021 truncated: false,
4022 continues: false,
4023 }),
4024 }),
4025 ],
4026 });
4027
4028 const result = yield* service.list({
4029 state: "open",
4030 filters: { labels: [["size:S", "size:XS"], ["bug"]] },
4031 });
4032
4033 assert.deepStrictEqual(
4034 result.entries.map((entry) => entry.number),
4035 [1, 2],
4036 );
4037 }),
4038 );
4039
4040 it.effect.each([false, true])(
4041 "authorizes stack rebases and refreshes sibling layers (cross-host: %s)",
4042 (crossHost) =>
4043 Effect.gen(function* () {
4044 let taken = 0;
4045 let summaryReads = 0;
4046 let mutationFails = false;
4047 let stackRebase = true;
4048 let stackActions = true;
4049 const capabilities = {
4050 diff: true,
4051 comment: true,
4052 actions: ["update-branch"] as const,
4053 mergeMethods: ["merge"] as const,
4054 updateMethods: ["rebase"] as const,
4055 get stackActions() {
4056 return stackActions;
4057 },
4058 search: true,
4059 reactions: true,
4060 review: FULL_REVIEW,
4061 reviewers: FULL_REVIEWERS,
4062 };
4063 const service = yield* makeService({
4064 projects: [
4065 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
4066 project({
4067 id: "p2",
4068 title: "enterprise",
4069 workspaceRoot: "/b",
4070 repository: "acme/web",
4071 host: "enterprise.test",
4072 }),
4073 ],
4074 providers: [
4075 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
4076 capabilities,
4077 getViewerPermissions: () =>
4078 Effect.succeed({
4079 actions: [],
4080 stackRebase,
4081 comment: true,
4082 resolve: false,
4083 verdicts: [],
4084 requestReviewers: false,
4085 }),
4086 getChangeRequestSummary: () =>
4087 Effect.sync(() => {
4088 summaryReads++;
4089 return changeRequest(8, "2026-07-01T00:00:00Z");
4090 }),
4091 runAction: () =>
4092 Effect.gen(function* () {
4093 taken++;
4094 if (mutationFails) return yield* requestFailed;
4095 }),
4096 }),
4097 ],
4098 });
4099 const input = {
4100 ...(crossHost ? { host: "enterprise.test" } : {}),
4101 projectId: "p1" as ProjectId,
4102 repository: "acme/web",
4103 number: 3,
4104 action: "update-branch" as const,
4105 updateMethod: "rebase" as const,
4106 stackNumber: 50,
4107 expectedStackHeads: [{ number: 3, headSha: "ccc" }],
4108 };
4109 yield* service.runAction(input);
4110 assert.strictEqual(taken, 1);
4111 const unrelated = { ...input, number: 8 };
4112 yield* service.summary(unrelated);
4113 assert.strictEqual(summaryReads, 1);
4114 stackRebase = false;
4115 assert.strictEqual(
4116 (yield* Effect.flip(service.runAction(input)))._tag,
4117 "PullRequestOperationError",
4118 );
4119 stackRebase = true;
4120 stackActions = false;
4121 assert.strictEqual(
4122 (yield* Effect.flip(service.runAction(input)))._tag,
4123 "PullRequestOperationError",
4124 );
4125 assert.strictEqual(taken, 1);
4126 yield* service.summary(unrelated);
4127 assert.strictEqual(summaryReads, 1);
4128 stackActions = true;
4129 mutationFails = true;
4130 yield* Effect.flip(service.runAction(input));
4131 assert.strictEqual(taken, 2);
4132 yield* service.summary(unrelated);
4133 assert.strictEqual(summaryReads, 2);
4134 }),
4135 );
4136
4137 it.effect("refuses a way of updating a branch that the host or the viewer does not allow", () =>
4138 Effect.gen(function* () {
4139 let taken: string | null = null;
4140 const service = yield* makeService({
4141 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
4142 providers: [
4143 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
4144 capabilities: {
4145 diff: true,
4146 comment: true,
4147 actions: ["merge", "close", "update-branch"],
4148 mergeMethods: ["merge"],
4149 updateMethods: ["merge"],
4150 search: true,
4151 reactions: true,
4152 review: FULL_REVIEW,
4153 reviewers: FULL_REVIEWERS,
4154 },
4155 getViewerPermissions: () =>
4156 Effect.succeed({
4157 actions: ["close", "update-branch"],
4158 comment: true,
4159 resolve: true,
4160 verdicts: ["comment"],
4161 requestReviewers: false,
4162 updateMethods: ["merge"],
4163 }),
4164 runAction: (input) => {
4165 taken = input.updateMethod ?? "default";
4166 return Effect.void;
4167 },
4168 }),
4169 ],
4170 });
4171 const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
4172
4173 const error = yield* Effect.flip(
4174 service.runAction({ ...reference, action: "update-branch", updateMethod: "rebase" }),
4175 );
4176 assert.strictEqual(error._tag, "PullRequestOperationError");
4177 assert.strictEqual(taken, null);
4178
4179 yield* service.runAction({ ...reference, action: "update-branch", updateMethod: "merge" });
4180 assert.strictEqual(taken, "merge");
4181 }),
4182 );
4183
4184 it.effect("keeps reading a host's thinned-out slices until a filtered page is full", () =>
4185 Effect.gen(function* () {
4186 const reads: Array<number> = [];
4187 const rows = Array.from({ length: 40 }, (_, index) => ({
4188 ...changeRequest(index + 1, `2026-07-${String(40 - index).padStart(2, "0")}T00:00:00Z`),
4189 labels: index % 2 === 0 ? [{ name: "bug", color: null }] : [],
4190 }));
4191 const service = yield* makeService({
4192 projects: [
4193 project({
4194 id: "p1",
4195 title: "on gitlab",
4196 workspaceRoot: "/a",
4197 repository: "group/project",
4198 provider: SourceControlProviderKind.make("gitlab"),
4199 }),
4200 ],
4201 providers: [
4202 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
4203 listChangeRequests: (input) => {
4204 const delivered = input.cursor?.delivered ?? 0;
4205 reads.push(delivered);
4206 return Effect.succeed({
4207 items: rows.slice(delivered, delivered + input.limit),
4208 truncated: delivered + input.limit < rows.length,
4209 continues: true,
4210 });
4211 },
4212 }),
4213 ],
4214 });
4215
4216 const bugs = yield* service.list({ state: "open", limit: 4, filters: { labels: [["bug"]] } });
4217 assert.deepStrictEqual(
4218 bugs.entries.map((entry) => entry.number),
4219 [1, 3, 5, 7],
4220 );
4221 assert.deepStrictEqual(reads, [0, 4]);
4222
4223 reads.length = 0;
4224 const none = yield* service.list({
4225 state: "open",
4226 limit: 4,
4227 filters: { labels: [["missing"]] },
4228 });
4229 assert.deepStrictEqual(none.entries, []);
4230 assert.strictEqual(reads.length, 5);
4231 assert.match(Object.values(none.nextCursors)[0] ?? "", /\|20\|/);
4232 }),
4233 );
4234
4235 it.effect("hands a host's own resume position back on the next read", () =>
4236 Effect.gen(function* () {
4237 const resumed: Array<string | undefined> = [];
4238 const service = yield* makeService({
4239 projects: [
4240 project({
4241 id: "p1",
4242 title: "on gitlab",
4243 workspaceRoot: "/a",
4244 repository: "group/project",
4245 provider: SourceControlProviderKind.make("gitlab"),
4246 }),
4247 ],
4248 providers: [
4249 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
4250 listChangeRequests: (input) => {
4251 resumed.push(input.cursor?.resumeAfter);
4252 return Effect.succeed({
4253 items: [changeRequest(resumed.length, "2026-07-02T00:00:00Z")],
4254 truncated: true,
4255 continues: true,
4256 resumeAfter: `2026-07-01T00:00:00.000Z~${resumed.length}`,
4257 });
4258 },
4259 }),
4260 ],
4261 });
4262
4263 const first = yield* service.list({ state: "open", limit: 1 });
4264 yield* service.list({ state: "open", limit: 1, cursors: first.nextCursors });
4265 assert.deepStrictEqual(resumed, [undefined, "2026-07-01T00:00:00.000Z~1"]);
4266 }),
4267 );
4268
4269 it.effect("judges review and checks filters only on a host that summarises them", () =>
4270 Effect.gen(function* () {
4271 const service = yield* makeService({
4272 projects: [
4273 project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
4274 project({
4275 id: "p2",
4276 title: "on gitlab",
4277 workspaceRoot: "/b",
4278 repository: "group/project",
4279 provider: SourceControlProviderKind.make("gitlab"),
4280 }),
4281 ],
4282 providers: [
4283 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
4284 listChangeRequests: () =>
4285 Effect.succeed({
4286 items: [
4287 {
4288 ...changeRequest(1, "2026-07-02T00:00:00Z"),
4289 reviewDecision: null,
4290 checksState: "failing" as const,
4291 },
4292 {
4293 ...changeRequest(2, "2026-07-02T00:00:00Z"),
4294 reviewDecision: "approved" as const,
4295 checksState: null,
4296 },
4297 ],
4298 truncated: false,
4299 continues: true,
4300 }),
4301 }),
4302 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
4303 listChangeRequests: () =>
4304 Effect.succeed({
4305 items: [changeRequest(3, "2026-07-02T00:00:00Z")],
4306 truncated: false,
4307 continues: true,
4308 }),
4309 }),
4310 ],
4311 });
4312
4313 const none = yield* service.list({ state: "open", filters: { review: "none" } });
4314 assert.deepStrictEqual(none.entries.map((entry) => entry.number).toSorted(), [1, 3]);
4315
4316 const approved = yield* service.list({ state: "open", filters: { review: "approved" } });
4317 assert.deepStrictEqual(approved.entries.map((entry) => entry.number).toSorted(), [2, 3]);
4318
4319 const failing = yield* service.list({ state: "open", filters: { checks: "failing" } });
4320 assert.deepStrictEqual(failing.entries.map((entry) => entry.number).toSorted(), [1, 3]);
4321
4322 const passing = yield* service.list({ state: "open", filters: { checks: "passing" } });
4323 assert.deepStrictEqual(passing.entries.map((entry) => entry.number).toSorted(), [3]);
4324 }),
4325 );
4326
4327 it.effect("partial host viewed writes invalidate marks but keep the diff cached", () =>
4328 Effect.gen(function* () {
4329 let diffReads = 0;
4330 const states = new Map<string, "viewed" | "unviewed">([
4331 ["a.ts", "unviewed"],
4332 ["b.ts", "unviewed"],
4333 ]);
4334 const service = yield* makeService({
4335 projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
4336 providers: [
4337 fakePullRequestProvider(SourceControlProviderKind.make("github"), {
4338 capabilities: {
4339 ...fakePullRequestProvider(SourceControlProviderKind.make("github")).capabilities,
4340 viewedFiles: "host",
4341 },
4342 getDiff: () =>
4343 Effect.sync(() => {
4344 diffReads += 1;
4345 return { patch: "@@", truncated: false, nextCursor: null };
4346 }),
4347 getFilesViewed: () =>
4348 Effect.sync(() => ({
4349 files: [...states].map(([path, state]) => ({ path, state })),
4350 truncated: false,
4351 })),
4352 setFilesViewed: () =>
4353 Effect.gen(function* () {
4354 states.set("a.ts", "viewed");
4355 return yield* new PullRequestProviderError({
4356 provider: SourceControlProviderKind.make("github"),
4357 operation: "setFilesViewed",
4358 reason: "failed",
4359 detail: "Second mutation refused",
4360 });
4361 }),
4362 }),
4363 ],
4364 });
4365 const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 10 };
4366 yield* service.diff(ref);
4367 assert.deepStrictEqual((yield* service.filesViewed(ref)).files, [
4368 { path: "a.ts", state: "unviewed" },
4369 { path: "b.ts", state: "unviewed" },
4370 ]);
4371 yield* Effect.flip(
4372 service.setFilesViewed({
4373 ...ref,
4374 files: [...states.keys()].map((path) => ({ path, viewed: true })),
4375 }),
4376 );
4377 yield* service.diff(ref);
4378 assert.strictEqual(diffReads, 1);
4379 assert.deepStrictEqual((yield* service.filesViewed(ref)).files, [
4380 { path: "a.ts", state: "viewed" },
4381 { path: "b.ts", state: "unviewed" },
4382 ]);
4383 }),
4384 );
4385
4386 const environmentViewedProvider = (
4387 revisions: Map<string, string>,
4388 asked: Array<ReadonlyArray<string>>,
4389 unreadable: ReadonlySet<string> = new Set(),
4390 ) =>
4391 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
4392 capabilities: {
4393 diff: true,
4394 comment: true,
4395 actions: ["merge"],
4396 mergeMethods: ["merge"],
4397 search: true,
4398 reactions: true,
4399 viewedFiles: "environment",
4400 review: FULL_REVIEW,
4401 reviewers: FULL_REVIEWERS,
4402 },
4403 getFilesViewed: () => Effect.die("the host keeps no marks of its own"),
4404 setFilesViewed: () => Effect.die("the host keeps no marks of its own"),
4405 getChangeRequestSummary: () => Effect.succeed(changeRequest(1, "2026-07-02T00:00:00Z")),
4406 getFileRevisions: (input) => {
4407 asked.push(input.paths);
4408 return Effect.succeed({
4409 revisions: new Map(
4410 input.paths.flatMap((path) =>
4411 unreadable.has(path) ? [] : [[path, revisions.get(path) ?? ""] as const],
4412 ),
4413 ),
4414 });
4415 },
4416 });
4417
4418 const environmentViewedService = (
4419 revisions: Map<string, string>,
4420 asked: Array<ReadonlyArray<string>>,
4421 unreadable: ReadonlySet<string> = new Set(),
4422 ) =>
4423 makeService({
4424 projects: [
4425 project({
4426 id: "p1",
4427 title: "on gitlab",
4428 workspaceRoot: "/a",
4429 repository: "group/project",
4430 provider: SourceControlProviderKind.make("gitlab"),
4431 }),
4432 ],
4433 providers: [environmentViewedProvider(revisions, asked, unreadable)],
4434 });
4435
4436 const GITLAB_REFERENCE = {
4437 projectId: "p1" as ProjectId,
4438 repository: "group/project",
4439 number: 1,
4440 };
4441
4442 it.effect("tracks environment viewed files by revision and refuses a baseline it cannot read", () =>
4443 Effect.gen(function* () {
4444 const revisions = new Map([
4445 ["alpha.ts", "b485fe5"],
4446 ["beta.ts", "5851425"],
4447 ["café notes.txt", "6dd9855"],
4448 ["deleted.txt", "0000000"],
4449 ["renamed.txt", ""],
4450 ]);
4451 let unreadable = false;
4452 let revisionReads = 0;
4453 const service = yield* makeService({
4454 projects: [
4455 project({
4456 id: "p1",
4457 title: "on gitlab",
4458 workspaceRoot: "/a",
4459 repository: "group/project",
4460 provider: SourceControlProviderKind.make("gitlab"),
4461 }),
4462 ],
4463 providers: [
4464 {
4465 ...environmentViewedProvider(revisions, []),
4466 getFileRevisions: (input) =>
4467 Effect.suspend(() => {
4468 revisionReads++;
4469 return unreadable
4470 ? Effect.fail(
4471 new PullRequestProviderError({
4472 provider: SourceControlProviderKind.make("gitlab"),
4473 operation: "getFileRevisions",
4474 reason: "failed",
4475 detail: "The diff exceeded the output limit.",
4476 }),
4477 )
4478 : Effect.succeed({
4479 revisions: new Map(
4480 input.paths.map((path) => [path, revisions.get(path) ?? ""] as const),
4481 ),
4482 complete: true,
4483 });
4484 }),
4485 },
4486 ],
4487 });
4488 const reference = GITLAB_REFERENCE;
4489 const paths = [...revisions.keys()];
4490 yield* service.setFilesViewed({
4491 ...reference,
4492 files: paths.map((path) => ({ path, viewed: true })),
4493 });
4494 assert.deepStrictEqual(
4495 new Map((yield* service.filesViewed(reference)).files.map((file) => [file.path, file.state])),
4496 new Map(paths.map((path) => [path, "viewed"])),
4497 );
4498 assert.strictEqual(revisionReads, 1);
4499
4500 revisions.set("alpha.ts", "aabbccd");
4501 yield* service.invalidate({ reference });
4502 assert.deepStrictEqual(
4503 new Map((yield* service.filesViewed(reference)).files.map((file) => [file.path, file.state])),
4504 new Map(paths.map((path) => [path, path === "alpha.ts" ? "dismissed" : "viewed"])),
4505 );
4506 yield* service.setFilesViewed({
4507 ...reference,
4508 files: [{ path: "beta.ts", viewed: false }],
4509 });
4510 assert.isFalse(
4511 (yield* service.filesViewed(reference)).files.some((file) => file.path === "beta.ts"),
4512 );
4513
4514 unreadable = true;
4515 yield* service.invalidate({ reference });
4516 yield* service.setFilesViewed({
4517 ...reference,
4518 files: [{ path: "beta.ts", viewed: true }],
4519 });
4520 unreadable = false;
4521 yield* service.invalidate({ reference });
4522 assert.deepStrictEqual(
4523 (yield* service.filesViewed(reference)).files.find((file) => file.path === "beta.ts"),
4524 { path: "beta.ts", state: "viewed" },
4525 );
4526 }),
4527 );
4528
4529 it.effect("keeps hosted Forgejo marks with their repository instead of the serving checkout", () =>
4530 Effect.gen(function* () {
4531 const projects = [
4532 project({
4533 id: "p1",
4534 title: "first repository",
4535 workspaceRoot: "/first",
4536 repository: "reviewer/first",
4537 provider: SourceControlProviderKind.make("forgejo"),
4538 host: "forge.example",
4539 remoteUrl: "https://forge.example:3000/reviewer/first.git",
4540 }),
4541 ];
4542 const service = yield* makeService({
4543 projects,
4544 providers: [
4545 {
4546 ...environmentViewedProvider(new Map([["same.ts", "blob"]]), []),
4547 kind: SourceControlProviderKind.make("forgejo"),
4548 },
4549 ],
4550 resolveHandle: ({ context }) =>
4551 Effect.succeed({
4552 context: {
4553 ...context!,
4554 provider: {
4555 kind: SourceControlProviderKind.make("forgejo"),
4556 name: "Forgejo",
4557 baseUrl: "https://forge.example:3000",
4558 },
4559 },
4560 provider: undefined as never,
4561 }),
4562 });
4563 const first = {
4564 projectId: "p1" as ProjectId,
4565 host: "forge.example:3000",
4566 repository: "reviewer/first",
4567 number: 1,
4568 };
4569 const second = { ...first, repository: "reviewer/second" };
4570 const files = [{ path: "same.ts", viewed: true }];
4571 yield* service.setFilesViewed({ ...first, files });
4572 assert.deepStrictEqual((yield* service.filesViewed(second)).files, []);
4573 yield* service.setFilesViewed({ ...second, files });
4574 yield* service.setFilesViewed({ ...first, files: [{ path: "same.ts", viewed: false }] });
4575 assert.deepStrictEqual((yield* service.filesViewed(second)).files, [
4576 { path: "same.ts", state: "viewed" },
4577 ]);
4578
4579 projects.push(
4580 project({
4581 id: "p2",
4582 title: "second repository",
4583 workspaceRoot: "/second",
4584 repository: "reviewer/second",
4585 provider: SourceControlProviderKind.make("forgejo"),
4586 host: "forge.example",
4587 remoteUrl: "https://forge.example:3000/reviewer/second.git",
4588 }),
4589 );
4590 assert.deepStrictEqual(
4591 (yield* service.filesViewed({ ...second, projectId: "p2" as ProjectId })).files,
4592 [{ path: "same.ts", state: "viewed" }],
4593 );
4594 projects.push(
4595 project({
4596 id: "ssh",
4597 title: "second repository over SSH",
4598 workspaceRoot: "/ssh",
4599 repository: "reviewer/second",
4600 provider: SourceControlProviderKind.make("forgejo"),
4601 host: "ssh.forge.example",
4602 remoteUrl: "git@ssh.forge.example:reviewer/second.git",
4603 }),
4604 );
4605 assert.deepStrictEqual(
4606 (yield* service.filesViewed({ ...second, projectId: "ssh" as ProjectId })).files,
4607 [{ path: "same.ts", state: "viewed" }],
4608 );
4609 }),
4610 );
4611
4612 it.effect("keeps viewed files itself for a host that keeps none of its own", () =>
4613 Effect.gen(function* () {
4614 const asked: Array<ReadonlyArray<string>> = [];
4615 const service = yield* environmentViewedService(
4616 new Map([
4617 ["src/a.ts", "blob-a"],
4618 ["src/b.ts", "blob-b"],
4619 ]),
4620 asked,
4621 );
4622
4623 const empty = yield* service.filesViewed(GITLAB_REFERENCE);
4624 assert.deepStrictEqual(empty, { files: [], truncated: false });
4625 assert.deepStrictEqual(asked, []);
4626
4627 yield* service.setFilesViewed({
4628 ...GITLAB_REFERENCE,
4629 files: [
4630 { path: "src/a.ts", viewed: true },
4631 { path: "src/b.ts", viewed: true },
4632 ],
4633 });
4634 const marked = yield* service.filesViewed(GITLAB_REFERENCE);
4635
4636 assert.deepStrictEqual(
4637 [...marked.files].toSorted((left, right) => left.path.localeCompare(right.path)),
4638 [
4639 { path: "src/a.ts", state: "viewed" },
4640 { path: "src/b.ts", state: "viewed" },
4641 ],
4642 );
4643 assert.strictEqual(marked.truncated, false);
4644 assert.deepStrictEqual(
4645 asked.map((paths) => [...paths].toSorted()),
4646 [["src/a.ts", "src/b.ts"]],
4647 );
4648 }),
4649 );
4650
4651 it.effect("records shown revisions until the reader ticks the pushed version", () =>
4652 Effect.gen(function* () {
4653 const asked: Array<ReadonlyArray<string>> = [];
4654 const revisions = new Map([
4655 ["src/a.ts", "pushed-a"],
4656 ["src/b.ts", "current-b"],
4657 ]);
4658 const service = yield* environmentViewedService(revisions, asked);
4659
4660 yield* service.setFilesViewed({
4661 ...GITLAB_REFERENCE,
4662 files: [
4663 { path: "src/a.ts", viewed: true, revision: "shown-a" },
4664 { path: "src/b.ts", viewed: true },
4665 ],
4666 });
4667 assert.deepStrictEqual(asked, [["src/b.ts"]]);
4668 yield* service.invalidate({ reference: GITLAB_REFERENCE });
4669 assert.deepStrictEqual((yield* service.filesViewed(GITLAB_REFERENCE)).files, [
4670 { path: "src/a.ts", state: "dismissed" },
4671 { path: "src/b.ts", state: "viewed" },
4672 ]);
4673
4674 const reads = asked.length;
4675 revisions.set("src/a.ts", "pushed-a-again");
4676 yield* service.setFilesViewed({
4677 ...GITLAB_REFERENCE,
4678 files: [{ path: "src/a.ts", viewed: true, revision: "pushed-a-again" }],
4679 });
4680 assert.strictEqual(asked.length, reads);
4681 assert.deepStrictEqual((yield* service.filesViewed(GITLAB_REFERENCE)).files, [
4682 { path: "src/a.ts", state: "viewed" },
4683 { path: "src/b.ts", state: "viewed" },
4684 ]);
4685 }),
4686 );
4687
4688 it.effect("keeps a deleted file cleared, which the head has no version of at all", () =>
4689 Effect.gen(function* () {
4690 const service = yield* environmentViewedService(new Map(), []);
4691
4692 yield* service.setFilesViewed({
4693 ...GITLAB_REFERENCE,
4694 files: [{ path: "src/gone.ts", viewed: true }],
4695 });
4696 yield* service.invalidate({ reference: GITLAB_REFERENCE });
4697 const marked = yield* service.filesViewed(GITLAB_REFERENCE);
4698
4699 assert.deepStrictEqual(marked.files, [{ path: "src/gone.ts", state: "viewed" }]);
4700 }),
4701 );
4702
4703 it.effect("leaves a mark alone when the host could not say what the head has of it", () =>
4704 Effect.gen(function* () {
4705 const revisions = new Map([
4706 ["src/a.ts", "blob-a"],
4707 ["src/past-the-cut.ts", "blob-b"],
4708 ]);
4709 const service = yield* environmentViewedService(
4710 revisions,
4711 [],
4712 new Set(["src/past-the-cut.ts"]),
4713 );
4714
4715 yield* service.setFilesViewed({
4716 ...GITLAB_REFERENCE,
4717 files: [
4718 { path: "src/a.ts", viewed: true },
4719 { path: "src/past-the-cut.ts", viewed: true },
4720 ],
4721 });
4722 revisions.set("src/a.ts", "blob-a-again");
4723 yield* service.invalidate({ reference: GITLAB_REFERENCE });
4724 const marked = yield* service.filesViewed(GITLAB_REFERENCE);
4725
4726 assert.deepStrictEqual(
4727 [...marked.files].toSorted((left, right) => left.path.localeCompare(right.path)),
4728 [
4729 { path: "src/a.ts", state: "dismissed" },
4730 { path: "src/past-the-cut.ts", state: "viewed" },
4731 ],
4732 );
4733 }),
4734 );
4735
4736 it.effect("reports a file pushed to after the diff the reader ticked was drawn as changed", () =>
4737 Effect.gen(function* () {
4738 const revisions = new Map([["src/a.ts", "shown-a"]]);
4739 const service = yield* environmentViewedService(revisions, []);
4740
4741 yield* service.filesViewed(GITLAB_REFERENCE);
4742 yield* TestClock.adjust("61 seconds");
4743 revisions.set("src/a.ts", "pushed-a");
4744 yield* service.setFilesViewed({
4745 ...GITLAB_REFERENCE,
4746 files: [{ path: "src/a.ts", viewed: true, revision: "shown-a" }],
4747 });
4748 yield* service.invalidate({ reference: GITLAB_REFERENCE });
4749
4750 assert.deepStrictEqual((yield* service.filesViewed(GITLAB_REFERENCE)).files, [
4751 { path: "src/a.ts", state: "dismissed" },
4752 ]);
4753 }),
4754 );
4755
4756 it.effect("forgets what the head had of a marked file once a mutation moves the head", () =>
4757 Effect.gen(function* () {
4758 const revisions = new Map([["src/a.ts", "blob-a"]]);
4759 const service = yield* environmentViewedService(revisions, []);
4760
4761 yield* service.setFilesViewed({
4762 ...GITLAB_REFERENCE,
4763 files: [{ path: "src/a.ts", viewed: true }],
4764 });
4765 revisions.set("src/a.ts", "blob-a-again");
4766 yield* service.runAction({ ...GITLAB_REFERENCE, action: "merge" });
4767
4768 assert.deepStrictEqual((yield* service.filesViewed(GITLAB_REFERENCE)).files, [
4769 { path: "src/a.ts", state: "dismissed" },
4770 ]);
4771 }),
4772 );
4773
4774 it.effect("finishes two presses on one file in the order they were made", () =>
4775 Effect.gen(function* () {
4776 const held = yield* Deferred.make<void>();
4777 const service = yield* makeService({
4778 projects: [
4779 project({
4780 id: "p1",
4781 title: "on gitlab",
4782 workspaceRoot: "/a",
4783 repository: "group/project",
4784 provider: SourceControlProviderKind.make("gitlab"),
4785 }),
4786 ],
4787 providers: [
4788 fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
4789 capabilities: {
4790 diff: true,
4791 comment: true,
4792 actions: ["merge"],
4793 mergeMethods: ["merge"],
4794 search: true,
4795 reactions: true,
4796 viewedFiles: "environment",
4797 review: FULL_REVIEW,
4798 reviewers: FULL_REVIEWERS,
4799 },
4800 getFilesViewed: () => Effect.die("the host keeps no marks of its own"),
4801 setFilesViewed: () => Effect.die("the host keeps no marks of its own"),
4802 getFileRevisions: (input) =>
4803 Deferred.await(held).pipe(
4804 Effect.as({ revisions: new Map(input.paths.map((path) => [path, "blob-a"])) }),
4805 ),
4806 }),
4807 ],
4808 });
4809
4810 const tick = yield* service
4811 .setFilesViewed({
4812 ...GITLAB_REFERENCE,
4813 files: [{ path: "src/a.ts", viewed: true }],
4814 })
4815 .pipe(Effect.forkChild({ startImmediately: true }));
4816 yield* TestClock.adjust("1 second");
4817 const untick = yield* service
4818 .setFilesViewed({
4819 ...GITLAB_REFERENCE,
4820 files: [{ path: "src/a.ts", viewed: false }],
4821 })
4822 .pipe(Effect.forkChild({ startImmediately: true }));
4823 yield* TestClock.adjust("1 second");
4824 yield* Deferred.succeed(held, undefined);
4825 yield* Fiber.join(tick);
4826 yield* Fiber.join(untick);
4827
4828 const marked = yield* service.filesViewed(GITLAB_REFERENCE);
4829 assert.deepStrictEqual(marked.files, []);
4830 }),
4831 );
4832
4833 const azureViewedService = (projects: ReadonlyArray<OrchestrationProjectShell>) =>
4834 makeService({
4835 projects,
4836 providers: [
4837 fakePullRequestProvider(SourceControlProviderKind.make("azure-devops"), {
4838 ...keyedByCanonicalKey,
4839 capabilities: {
4840 diff: true,
4841 comment: true,
4842 actions: ["merge"],
4843 mergeMethods: ["merge"],
4844 search: true,
4845 reactions: true,
4846 viewedFiles: "environment",
4847 review: FULL_REVIEW,
4848 reviewers: FULL_REVIEWERS,
4849 },
4850 getFilesViewed: () => Effect.die("the host keeps no marks of this environment's own"),
4851 setFilesViewed: () => Effect.die("the host keeps no marks of this environment's own"),
4852 getFileRevisions: (input) =>
4853 Effect.succeed({ revisions: new Map(input.paths.map((path) => [path, "blob-a"])) }),
4854 }),
4855 ],
4856 });
4857
4858 const AZURE_PAIR = [
4859 project({
4860 id: "p1",
4861 title: "platform web",
4862 workspaceRoot: "/a",
4863 repository: "acme/platform/_git/web",
4864 provider: SourceControlProviderKind.make("azure-devops"),
4865 host: "dev.azure.com",
4866 }),
4867 project({
4868 id: "p2",
4869 title: "other web",
4870 workspaceRoot: "/b",
4871 repository: "acme/other/_git/web",
4872 provider: SourceControlProviderKind.make("azure-devops"),
4873 host: "dev.azure.com",
4874 }),
4875 ];
4876
4877 const AZURE_PLATFORM = { projectId: "p1" as ProjectId, repository: "web", number: 1 };
4878 const AZURE_OTHER = { projectId: "p2" as ProjectId, repository: "web", number: 1 };
4879
4880 it.effect("keeps the marks of two Azure repositories of the same name apart", () =>
4881 Effect.gen(function* () {
4882 const service = yield* azureViewedService(AZURE_PAIR);
4883
4884 yield* service.setFilesViewed({
4885 ...AZURE_PLATFORM,
4886 files: [{ path: "src/a.ts", viewed: true }],
4887 });
4888
4889 assert.deepStrictEqual((yield* service.filesViewed(AZURE_PLATFORM)).files, [
4890 { path: "src/a.ts", state: "viewed" },
4891 ]);
4892 assert.deepStrictEqual((yield* service.filesViewed(AZURE_OTHER)).files, []);
4893 }),
4894 );
4895
4896 it.effect("keeps environment marks apart from another change request's", () =>
4897 Effect.gen(function* () {
4898 const service = yield* environmentViewedService(new Map([["src/a.ts", "blob-a"]]), []);
4899
4900 yield* service.setFilesViewed({
4901 ...GITLAB_REFERENCE,
4902 files: [{ path: "src/a.ts", viewed: true }],
4903 });
4904 const other = yield* service.filesViewed({ ...GITLAB_REFERENCE, number: 2 });
4905
4906 assert.deepStrictEqual(other.files, []);
4907 }),
4908 );
4909
4910 const environmentViewedServiceWithViewer = (
4911 revisions: Map<string, string>,
4912 getViewer: PullRequestProviderApi["getViewer"],
4913 ) =>
4914 makeService({
4915 projects: [
4916 project({
4917 id: "p1",
4918 title: "on gitlab",
4919 workspaceRoot: "/a",
4920 repository: "group/project",
4921 provider: SourceControlProviderKind.make("gitlab"),
4922 }),
4923 ],
4924 providers: [{ ...environmentViewedProvider(revisions, []), getViewer }],
4925 });
4926
4927 it.effect("keeps one reader's marks on a host that names nobody", () =>
4928 Effect.gen(function* () {
4929 const service = yield* environmentViewedServiceWithViewer(
4930 new Map([["src/a.ts", "blob-a"]]),
4931 () => Effect.succeed(""),
4932 );
4933
4934 yield* service.setFilesViewed({
4935 ...GITLAB_REFERENCE,
4936 files: [{ path: "src/a.ts", viewed: true }],
4937 });
4938
4939 assert.deepStrictEqual((yield* service.filesViewed(GITLAB_REFERENCE)).files, [
4940 { path: "src/a.ts", state: "viewed" },
4941 ]);
4942 }),
4943 );
4944
4945 it.effect("carries a bounded number of its own marks and says it held more", () =>
4946 Effect.gen(function* () {
4947 const asked: Array<ReadonlyArray<string>> = [];
4948 const paths = Array.from(
4949 { length: PullRequestFilesViewed.MAX_FILES_VIEWED_ROWS + 40 },
4950 (_, at) => `src/f${String(at).padStart(4, "0")}.ts`,
4951 );
4952 const service = yield* environmentViewedService(
4953 new Map(paths.map((path) => [path, "blob"] as const)),
4954 asked,
4955 );
4956
4957 yield* service.setFilesViewed({
4958 ...GITLAB_REFERENCE,
4959 files: paths.map((path) => ({ path, viewed: true })),
4960 });
4961 const read = yield* service.filesViewed(GITLAB_REFERENCE);
4962
4963 assert.lengthOf(read.files, PullRequestFilesViewed.MAX_FILES_VIEWED_ROWS);
4964 assert.strictEqual(read.truncated, true);
4965 }),
4966 );
4967
4968 it.effect("keeps Azure continuation cursors separate for repositories with the same name", () =>
4969 Effect.gen(function* () {
4970 const seen: string[] = [];
4971 const service = yield* makeService({
4972 projects: ["org-a", "org-b"].map((organization) =>
4973 project({
4974 id: organization,
4975 title: organization,
4976 workspaceRoot: `/${organization}`,
4977 repository: `${organization}/project/_git/web`,
4978 provider: SourceControlProviderKind.make("azure-devops"),
4979 host: "dev.azure.com",
4980 }),
4981 ),
4982 providers: [
4983 fakePullRequestProvider(SourceControlProviderKind.make("azure-devops"), {
4984 ...keyedByCanonicalKey,
4985 listChangeRequests: (input) =>
4986 Effect.sync(() => {
4987 seen.push(input.cwd);
4988 return {
4989 items: [changeRequest(7, "2026-07-02T00:00:00Z")],
4990 truncated: true,
4991 continues: true,
4992 };
4993 }),
4994 }),
4995 ],
4996 });
4997 const first = yield* service.list({ state: "open" });
4998 assert.lengthOf(Object.keys(first.nextCursors), 2);
4999 const key = Object.keys(first.nextCursors).find((key) => key.includes("org-b"))!;
5000 seen.length = 0;
Showing first 5,000 of 5,416 lines. View raw