import { SourceControlProviderKind } from "@t3tools/contracts";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as KeyValueStore from "effect/persistence/KeyValueStore";
import { assert, expect, it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";
import type {
OrchestrationProjectShell,
ProjectId,
PullRequestReviewCapabilities,
PullRequestReviewerCapabilities,
} from "@t3tools/contracts";
import { DEFAULT_SERVER_SETTINGS } from "@t3tools/contracts/settings";
import type { ServerSettings } from "@t3tools/contracts";
import * as ServerSettingsService from "../serverSettings.ts";
import { PullRequestOperationError } from "@t3tools/contracts";
import * as ProjectService from "../project/ProjectService.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import * as PullRequestFilesViewed from "../persistence/PullRequestFilesViewed.ts";
import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
import type { SourceControlProvider } from "@t3tools/source-control-core/server/SourceControlProvider";
import { isSshRemoteUrl } from "@t3tools/shared/sourceControl";
import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
import { fakePullRequestProvider } from "@t3tools/source-control-testing/fakeSourceControlDriver";
import {
PullRequestProviderError,
type ProviderChangeRequest,
type PullRequestProviderApi,
} from "@t3tools/source-control-core/server/PullRequestProvider";
import * as PullRequestProviderRegistry from "./PullRequestProviderRegistry.ts";
import * as PullRequestService from "./PullRequestService.ts";
import * as PullRequestReadCache from "./PullRequestReadCache.ts";
function project(input: {
readonly id: string;
readonly title: string;
readonly workspaceRoot: string;
readonly repository?: string;
readonly provider?: string;
readonly host?: string;
readonly remoteUrl?: string;
}): OrchestrationProjectShell {
const host = input.host ?? (input.provider === "gitlab" ? "gitlab.com" : "github.com");
return {
id: input.id as ProjectId,
title: input.title,
workspaceRoot: input.workspaceRoot,
...(input.repository
? {
repositoryIdentity: {
canonicalKey: `${host}/${input.repository}`,
locator: {
source: "git-remote" as const,
remoteName: "origin",
remoteUrl: input.remoteUrl ?? `https://${host}/${input.repository}.git`,
},
provider: SourceControlProviderKind.make(input.provider ?? "github"),
displayName: input.repository,
},
}
: {}),
defaultModelSelection: null,
scripts: [],
createdAt: "2026-07-01T00:00:00Z",
updatedAt: "2026-07-01T00:00:00Z",
};
}
function changeRequest(number: number, updatedAt: string): ProviderChangeRequest {
return {
number,
title: `Change request ${number}`,
url: `https://host/pull/${number}`,
author: { login: "octocat", name: null, avatarUrl: null },
headBranch: `feat/${number}`,
baseBranch: "main",
state: "open",
isDraft: false,
mergeability: "mergeable",
additions: 1,
deletions: 0,
createdAt: "2026-07-01T00:00:00Z",
updatedAt,
reviewRequestLogins: [],
labels: [],
};
}
function hostedChangeRequest(body: string, additions = 1) {
return {
...changeRequest(1, "2026-07-02T00:00:00Z"),
body,
additions,
changedFiles: 2,
mergedAt: null,
closedAt: null,
reviewers: [],
checks: [],
mergeCapabilities: { merge: true, squash: true, rebase: true },
viewerPermissions: {
actions: ["merge"] as const,
comment: true,
resolve: true,
verdicts: ["comment", "approve", "request-changes"] as const,
requestReviewers: true,
},
};
}
it.effect("reads maintainer edits and changes them through the update command", () =>
Effect.gen(function* () {
let enabled = true;
const provider = fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getChangeRequest: () =>
Effect.succeed({ ...hostedChangeRequest("Body"), maintainerCanModify: enabled }),
updateChangeRequest: (input) =>
Effect.sync(() => {
assert.strictEqual(input.title, undefined);
assert.strictEqual(input.body, undefined);
enabled = input.maintainerCanModify!;
}),
});
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
providers: [
{
...provider,
capabilities: {
...provider.capabilities,
edit: { changeRequest: true, comment: true, maintainerEdits: true },
},
},
],
});
const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
assert.strictEqual((yield* service.detail(ref)).maintainerCanModify, true);
yield* service.update({ ...ref, maintainerCanModify: false });
assert.strictEqual((yield* service.detail(ref)).maintainerCanModify, false);
}),
);
it.effect("refuses maintainer edits on a host without the capability", () =>
Effect.gen(function* () {
let writes = 0;
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
updateChangeRequest: () =>
Effect.sync(() => {
writes += 1;
}),
}),
],
});
const result = yield* service
.update({
projectId: "p1" as ProjectId,
repository: "acme/web",
number: 1,
maintainerCanModify: false,
})
.pipe(Effect.flip);
assert.strictEqual(result._tag, "PullRequestOperationError");
assert.strictEqual(writes, 0);
}),
);
it.effect("does not wait for an in-flight detail read to display a preview", () =>
Effect.gen(function* () {
const detailStarted = yield* Deferred.make<void>();
const releaseDetail = yield* Deferred.make<void>();
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getChangeRequest: () =>
Deferred.succeed(detailStarted, undefined).pipe(
Effect.andThen(Deferred.await(releaseDetail)),
Effect.as(hostedChangeRequest("Description")),
),
getChangeRequestPreview: () => Effect.succeed(changeRequest(1, "2026-07-02T00:00:00Z")),
}),
],
});
const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
const detail = yield* Effect.forkChild(service.detail(ref));
yield* Deferred.await(detailStarted);
assert.strictEqual((yield* service.preview(ref)).title, "Change request 1");
yield* Deferred.succeed(releaseDetail, undefined);
yield* Fiber.join(detail);
}),
);
it.effect("shows a listed pull request's preview without asking the host again", () =>
Effect.gen(function* () {
let previewReads = 0;
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: () =>
Effect.succeed({
items: [changeRequest(1, "2026-07-02T00:00:00Z")],
truncated: false,
continues: false,
}),
getChangeRequestPreview: () =>
Effect.sync(() => {
previewReads++;
return { ...changeRequest(1, "2026-07-02T00:00:00Z"), title: "Renamed" };
}),
}),
],
});
const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
yield* service.list({ state: "open" });
assert.strictEqual((yield* service.preview(ref)).title, "Change request 1");
assert.strictEqual(previewReads, 0);
yield* service.refreshAfterTurn(ref.projectId);
assert.strictEqual((yield* service.preview(ref)).title, "Renamed");
assert.strictEqual(previewReads, 1);
yield* service.list({ state: "open", limit: 1 });
assert.strictEqual((yield* service.preview(ref)).title, "Renamed");
}),
);
it.effect("a list read under a pinned account leaves the shared preview to the host", () =>
Effect.gen(function* () {
let previewReads = 0;
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getRoutingIdentity: () => Effect.succeed({ accountId: "101", viewer: "octocat" }),
withVerifiedCredential: (_, use) =>
use({ accountId: "101", viewer: "octocat", credentialFingerprint: "pinned" }),
listChangeRequests: () =>
Effect.succeed({
items: [{ ...changeRequest(1, "2026-07-02T00:00:00Z"), title: "Pinned view" }],
truncated: false,
continues: false,
}),
getChangeRequestPreview: () =>
Effect.sync(() => {
previewReads++;
return changeRequest(1, "2026-07-02T00:00:00Z");
}),
}),
],
});
const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
yield* service.withRoutingCredential(
{ ...ref, host: "github.com", expectedAccountId: "101" },
service.list({ state: "open" }),
);
assert.strictEqual((yield* service.preview(ref)).title, "Change request 1");
assert.strictEqual(previewReads, 1);
}),
);
function unusable(provider: SourceControlProviderKind, reason: "missing-tool" | "unauthenticated") {
return new PullRequestProviderError({
provider,
operation: "getViewer",
reason,
detail: `${provider} is not usable.`,
});
}
const requestFailed = new PullRequestProviderError({
provider: SourceControlProviderKind.make("github"),
operation: "listChangeRequests",
reason: "failed",
detail: "HTTP 404",
});
const FULL_REVIEW: PullRequestReviewCapabilities = {
inlineComment: true,
reply: true,
resolve: true,
verdicts: ["comment", "approve", "request-changes"],
};
const FULL_REVIEWERS: PullRequestReviewerCapabilities = { request: true, listCandidates: true };
// Like Azure DevOps, whose repository names repeat across organizations and projects.
const keyedByCanonicalKey = {
repositoryKey: ({ canonicalKey }: { readonly canonicalKey: string }) => canonicalKey,
};
/** A host whose SSH remotes name an alias, so discovery says which server serves them. */
const sshAliasHost = {
resolveRemoteWebHost: ({ cwd, context, resolveContext }) =>
isSshRemoteUrl(context.remoteUrl)
? resolveContext({
cwd,
context: {
...context,
provider: { kind: SourceControlProviderKind.make("unknown"), name: "", baseUrl: "" },
},
}).pipe(
Effect.map((resolved) =>
resolved === null || resolved.provider.kind === "unknown"
? null
: new URL(resolved.provider.baseUrl).host,
),
)
: Effect.succeed(null),
} as SourceControlProvider["Service"];
function makeService(input: {
readonly settings?: ServerSettings;
readonly projects: ReadonlyArray<OrchestrationProjectShell>;
readonly providers: ReadonlyArray<PullRequestProviderApi>;
readonly resolveHandle?: SourceControlProviderRegistry.SourceControlProviderRegistry["Service"]["resolveHandle"];
readonly resolveRepositoryIdentity?: RepositoryIdentityResolver.RepositoryIdentityResolver["Service"]["resolve"];
readonly onProjectRead?: () => void;
}) {
// Build in the test scope; per-call Effect.provide would close the marks database on service acquisition.
return Effect.flatMap(
Layer.build(
Layer.mergeAll(
Layer.mock(ServerSettingsService.ServerSettingsService)({
getSettings: Effect.succeed(input.settings ?? DEFAULT_SERVER_SETTINGS),
}),
Layer.succeed(
PullRequestProviderRegistry.PullRequestProviderRegistry,
PullRequestProviderRegistry.fromProviders(input.providers),
),
Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
resolveLink: () => undefined,
resolveHandle:
input.resolveHandle ?? (() => Effect.die("Unexpected provider refinement")),
get: (kind) =>
Effect.succeed(
kind === "forgejo" ? sshAliasHost : ({} as SourceControlProvider["Service"]),
),
}),
Layer.mock(ProjectService.ProjectService)({
listShells: (options) =>
Effect.sync(() => {
input.onProjectRead?.();
return input.projects.filter(
(project) => options?.projectIds?.includes(project.id) ?? true,
);
}),
getShell: (projectId) =>
Effect.sync(() => {
input.onProjectRead?.();
return Option.fromNullishOr(input.projects.find((p) => p.id === projectId));
}),
}),
Layer.mock(RepositoryIdentityResolver.RepositoryIdentityResolver)({
resolve: input.resolveRepositoryIdentity ?? (() => Effect.succeed(null)),
}),
SourceControlRateLimit.layer,
PullRequestFilesViewed.layer.pipe(Layer.provide(SqlitePersistence.layerMemory)),
Layer.effect(PullRequestReadCache.PullRequestReadCache, PullRequestReadCache.make).pipe(
Layer.provide(KeyValueStore.layerMemory),
Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
),
),
),
(context) => Effect.provideContext(PullRequestService.make, context),
);
}
it.effect("lists GitHub Enterprise PRs for a stored unknown repository after host discovery", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({
id: "p1",
title: "enterprise",
workspaceRoot: "/repo",
repository: "team/project",
provider: SourceControlProviderKind.make("unknown"),
host: "code.example.test",
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: ({ host, repository }) => {
assert.strictEqual(host, "code.example.test");
assert.strictEqual(repository, "team/project");
return Effect.succeed({
items: [changeRequest(42, "2026-07-05T00:00:00Z")],
truncated: false,
continues: false,
});
},
}),
],
resolveHandle: ({ context }) => {
assert.ok(context);
return Effect.succeed({
context: {
...context,
provider: {
...context.provider,
kind: SourceControlProviderKind.make("github"),
name: "GitHub Self-Hosted",
},
},
provider: undefined as never,
});
},
});
const result = yield* service.list({ state: "open" });
assert.deepStrictEqual(
result.entries.map(({ host, number }) => [host, number]),
[["code.example.test", 42]],
);
}),
);
it.effect("derives a legacy repository host after refining its provider", () =>
Effect.gen(function* () {
const current = project({
id: "p1",
title: "legacy self-hosted",
workspaceRoot: "/gitlab",
repository: "group/project",
provider: SourceControlProviderKind.make("unknown"),
host: "code.example.test",
});
const identity = current.repositoryIdentity!;
const legacy = {
...current,
repositoryIdentity: {
locator: identity.locator,
provider: identity.provider,
displayName: identity.displayName,
},
} as unknown as OrchestrationProjectShell;
const service = yield* makeService({
projects: [legacy],
providers: [fakePullRequestProvider(SourceControlProviderKind.make("gitlab"))],
resolveHandle: ({ context }) =>
Effect.succeed({
context: {
...context!,
provider: { ...context!.provider, kind: SourceControlProviderKind.make("gitlab") },
},
provider: undefined as never,
}),
});
const result = yield* service.list({ state: "open", host: "gitlab" });
assert.strictEqual(result.providers[0]?.host, "gitlab");
assert.strictEqual(result.providers[0]?.kind, "gitlab");
}),
);
it.effect("tries another checkout when provider refinement remains unknown", () =>
Effect.gen(function* () {
const asked: string[] = [];
const selfHosted = project({
id: "p1",
title: "self-hosted",
workspaceRoot: "/gone",
repository: "group/project",
provider: SourceControlProviderKind.make("unknown"),
host: "code.example.test",
});
const service = yield* makeService({
projects: [selfHosted, { ...selfHosted, id: "p2" as ProjectId, workspaceRoot: "/healthy" }],
providers: [fakePullRequestProvider(SourceControlProviderKind.make("gitlab"))],
resolveHandle: ({ cwd, context }) => {
asked.push(cwd);
return cwd === "/gone"
? Effect.succeed({ context: context!, provider: undefined as never })
: Effect.succeed({
context: {
...context!,
provider: { ...context!.provider, kind: SourceControlProviderKind.make("gitlab") },
},
provider: undefined as never,
});
},
});
const result = yield* service.list({ state: "open" });
assert.deepStrictEqual(asked, ["/gone", "/healthy"]);
assert.strictEqual(result.providers[0]?.kind, "gitlab");
}),
);
function batchedChangeRequest(number: number, repository: string, updatedAt: string) {
return { ...changeRequest(number, updatedAt), repository };
}
it.effect("reads nothing from a host with no implementation, but reports it", () =>
Effect.gen(function* () {
const listed: string[] = [];
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
project({ id: "p2", title: "notes", workspaceRoot: "/b" }),
project({
id: "p3",
title: "on gitlab",
workspaceRoot: "/c",
repository: "group/project",
provider: SourceControlProviderKind.make("gitlab"),
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: (input) => {
listed.push(input.repository);
return Effect.succeed({
items: [changeRequest(1, "2026-07-02T00:00:00Z")],
truncated: false,
continues: true,
});
},
}),
],
});
const result = yield* service.list({ state: "open" });
assert.deepStrictEqual(listed, ["pingdotgg/t3code"]);
assert.strictEqual(result.entries[0]?.provider, "github");
assert.deepStrictEqual(
result.providers.map((summary) => ({
kind: summary.kind,
configured: summary.configured,
projectCount: summary.projectCount,
})),
[
{ kind: SourceControlProviderKind.make("github"), configured: true, projectCount: 1 },
{ kind: SourceControlProviderKind.make("gitlab"), configured: false, projectCount: 1 },
],
);
}),
);
it.effect("reads nothing from a host its provider does not serve, but reports it", () =>
Effect.gen(function* () {
const reached = new Set<string>();
const bitbucket = (id: string, host: string) =>
project({
id,
title: host,
workspaceRoot: `/${id}`,
repository: "proj/repo",
provider: SourceControlProviderKind.make("bitbucket"),
host,
});
const service = yield* makeService({
projects: [bitbucket("p1", "bitbucket.org"), bitbucket("p2", "bitbucket.example.com")],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("bitbucket"), {
servesHost: (host) => host === "bitbucket.org",
getViewer: ({ host }) => {
reached.add(host ?? "");
return Effect.succeed("bilal");
},
listChangeRequests: ({ host }) => {
reached.add(host);
return Effect.succeed({ items: [], truncated: false, continues: false });
},
}),
],
});
const result = yield* service.list({ state: "open" });
assert.deepStrictEqual([...reached], ["bitbucket.org"]);
assert.deepStrictEqual(
result.providers.map(({ host, configured, detail }) => ({ host, configured, detail })),
[
{ host: "bitbucket.org", configured: true, detail: null },
{
host: "bitbucket.example.com",
configured: false,
detail: "This host cannot be browsed here yet.",
},
],
);
}),
);
it.effect("says where each repository carries on, and from nothing it has run out of", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
project({ id: "p2", title: "web", workspaceRoot: "/b", repository: "acme/web" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: ({ repository }) =>
Effect.succeed({
items: [changeRequest(1, "2026-07-02T00:00:00Z")],
truncated: repository === "pingdotgg/t3code",
continues: true,
}),
}),
],
});
const result = yield* service.list({ state: "open" });
assert.deepStrictEqual(result.nextCursors, {
"github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|1|1",
});
}),
);
it.effect("uses a provider's raw cursor advance when it consumed malformed rows", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({
id: "p1",
title: "web",
workspaceRoot: "/a",
repository: "acme/web",
provider: SourceControlProviderKind.make("azure-devops"),
host: "dev.azure.com",
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("azure-devops"), {
...keyedByCanonicalKey,
listChangeRequests: () =>
Effect.succeed({
items: [changeRequest(7, "2026-07-02T00:00:00Z")],
truncated: true,
cursorAdvance: 4,
continues: true,
}),
}),
],
});
const result = yield* service.list({ state: "open" });
assert.deepStrictEqual(result.nextCursors, {
"dev.azure.com dev.azure.com/acme/web": "2026-07-02T00:00:00Z|4|7",
});
}),
);
it.effect(
"continues a timestamp-paged host's listings through tied timestamps and terminates",
() =>
Effect.gen(function* () {
const boundary = "2026-10-12T00:00:00.000Z";
const older = "2026-10-11T00:00:00.000Z";
const rows = [1, 2, 3, 4, 5].map((number) =>
changeRequest(number, number <= 3 ? boundary : older),
);
const service = yield* makeService({
projects: [
project({
id: "p1",
title: "web",
workspaceRoot: "/w",
repository: "acme/web",
provider: "bitbucket",
host: "bitbucket.org",
}),
],
providers: [
// Pages the way Bitbucket does: inclusively by update time, excluding rows already sent.
fakePullRequestProvider(SourceControlProviderKind.make("bitbucket"), {
listChangeRequests: ({ cursor, limit }) =>
Effect.sync(() => {
const seen = new Set(cursor?.seenAt ?? []);
const matching = rows.filter(
(row) =>
(cursor === undefined || row.updatedAt <= cursor.updatedBefore) &&
!seen.has(row.number),
);
return {
items: matching.slice(0, limit),
truncated: matching.length > limit,
continues: true,
};
}),
}),
],
});
let page = yield* service.list({ state: "open", limit: 2 });
assert.deepStrictEqual(
page.entries.map((entry) => entry.number),
[1, 2],
);
for (const expected of [[3, 4], [5]]) {
assert.isTrue(page.truncated);
assert.isNotEmpty(page.nextCursors);
page = yield* service.list({ state: "open", limit: 2, cursors: page.nextCursors });
assert.deepStrictEqual(
page.entries.map((entry) => entry.number),
expected,
);
}
assert.isFalse(page.truncated);
assert.deepStrictEqual(page.nextCursors, {});
}),
);
it.effect("keeps a row already sent at the boundary instant from arriving twice", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: () =>
Effect.succeed({
items: [
changeRequest(7, "2026-07-02T00:00:00Z"),
changeRequest(8, "2026-07-02T00:00:00Z"),
changeRequest(9, "2026-07-01T00:00:00Z"),
],
truncated: true,
continues: true,
}),
}),
],
});
const result = yield* service.list({
state: "open",
cursors: { "github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|1|7" },
});
assert.deepStrictEqual(
result.entries.map((entry) => entry.number),
[8, 9],
);
assert.deepStrictEqual(result.nextCursors, {
"github.com pingdotgg/t3code": "2026-07-01T00:00:00Z|3|9",
});
}),
);
it.effect("keeps the earlier exclusions when a slice ends on the instant it began on", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: () =>
Effect.succeed({
items: [
changeRequest(7, "2026-07-02T00:00:00Z"),
changeRequest(8, "2026-07-02T00:00:00Z"),
],
truncated: true,
continues: true,
}),
}),
],
});
const result = yield* service.list({
state: "open",
cursors: { "github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|1|6" },
});
assert.deepStrictEqual(
result.entries.map((entry) => entry.number),
[7, 8],
);
assert.deepStrictEqual(result.nextCursors, {
"github.com pingdotgg/t3code": "2026-07-02T00:00:00Z|3|6,7,8",
});
}),
);
it.effect("calls a transient viewer failure a failed operation, not a signed-out CLI", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getViewer: () =>
Effect.fail(
new PullRequestProviderError({
provider: SourceControlProviderKind.make("github"),
operation: "getViewer",
reason: "failed",
detail: "HTTP 500",
}),
),
}),
],
});
const error = yield* Effect.flip(service.list({ state: "open" }));
assert.strictEqual(error._tag, "PullRequestOperationError");
}),
);
it.effect("reports an unusable host over a merely failing one", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
project({
id: "p2",
title: "on gitlab",
workspaceRoot: "/c",
repository: "group/project",
provider: SourceControlProviderKind.make("gitlab"),
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getViewer: () =>
Effect.fail(
new PullRequestProviderError({
provider: SourceControlProviderKind.make("github"),
operation: "getViewer",
reason: "failed",
detail: "HTTP 500",
}),
),
}),
fakePullRequestProvider(SourceControlProviderKind.make("gitlab"), {
unavailableRequirement: {
missing: "Install glab.",
unauthenticated: "Run glab auth login.",
},
getViewer: () =>
Effect.fail(unusable(SourceControlProviderKind.make("gitlab"), "missing-tool")),
}),
],
});
const error = yield* Effect.flip(service.list({ state: "open" }));
assert.strictEqual(error._tag, "PullRequestUnavailableError");
if (error._tag === "PullRequestUnavailableError") {
assert.strictEqual(error.requirement, "Install glab.");
}
assert.strictEqual(error.message, "Install glab.");
}),
);
it.effect("tells two hosts of one kind apart in the switcher and the filter", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "on github.com", workspaceRoot: "/a", repository: "ping/one" }),
project({
id: "p2",
title: "on the enterprise install",
workspaceRoot: "/b",
repository: "ping/two",
host: "ghe.example.com",
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: ({ host }) =>
Effect.succeed({
items: host === "ghe.example.com" ? [changeRequest(2, "2026-07-05T00:00:00Z")] : [],
truncated: false,
continues: true,
}),
}),
],
});
const all = yield* service.list({ state: "open" });
assert.deepStrictEqual(
all.providers.map((summary) => [summary.host, summary.kind, summary.projectCount]),
[
["github.com", "github", 1],
["ghe.example.com", "github", 1],
],
);
const scoped = yield* service.list({ state: "open", host: "ghe.example.com" });
assert.deepStrictEqual(
scoped.entries.map((entry) => [entry.host, entry.number]),
[["ghe.example.com", 2]],
);
}),
);
it.effect("reads a repository once when several worktrees share it", () =>
Effect.gen(function* () {
let calls = 0;
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
project({
id: "p2",
title: "t3code worktree",
workspaceRoot: "/b",
repository: "PingDotGG/T3Code",
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: () => {
calls += 1;
return Effect.succeed({
items: [changeRequest(1, "2026-07-02T00:00:00Z")],
truncated: false,
continues: true,
});
},
}),
],
});
const result = yield* service.list({ state: "open" });
assert.strictEqual(calls, 1);
assert.strictEqual(result.entries.length, 1);
}),
);
it.effect("keeps healthy repositories when one of them cannot be read", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
project({ id: "p2", title: "broken", workspaceRoot: "/b", repository: "pingdotgg/broken" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: (input) =>
input.repository === "pingdotgg/broken"
? Effect.fail(requestFailed)
: Effect.succeed({
items: [changeRequest(1, "2026-07-02T00:00:00Z")],
truncated: false,
continues: true,
}),
}),
],
});
const result = yield* service.list({ state: "open" });
assert.strictEqual(result.entries.length, 1);
assert.deepStrictEqual(
result.errors.map((error) => error.projectTitle),
["broken"],
);
}),
);
it.effect("offers each label once across repositories, despite one that cannot be read", () =>
Effect.gen(function* () {
const reads: Array<string> = [];
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
project({
id: "p5",
title: "t3code worktree",
workspaceRoot: "/e",
repository: "pingdotgg/t3code",
}),
project({
id: "p2",
title: "uploadthing",
workspaceRoot: "/b",
repository: "pingdotgg/ut",
}),
project({ id: "p3", title: "broken", workspaceRoot: "/c", repository: "pingdotgg/broken" }),
project({
id: "p4",
title: "elsewhere",
workspaceRoot: "/d",
repository: "group/app",
provider: "gitlab",
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listRepositoryLabels: (input) => {
reads.push(input.repository);
return input.repository === "pingdotgg/broken"
? Effect.fail(requestFailed)
: Effect.succeed({
items:
input.repository === "pingdotgg/t3code"
? [
{ name: "size:XL", color: "d93f0b" },
{ name: "bug", color: "d73a4a" },
]
: [{ name: "Bug", color: "ee0701" }],
truncated: false,
});
},
}),
// A host with no repository labels is left out rather than failing the answer.
fakePullRequestProvider(SourceControlProviderKind.make("gitlab")),
],
});
const result = yield* service.filterOptions({ kind: "labels" });
assert.deepStrictEqual(
result.labels.map((label) => label.name),
["bug", "size:XL"],
);
assert.strictEqual(reads.filter((repository) => repository === "pingdotgg/t3code").length, 1);
assert.strictEqual(result.truncated, false);
}),
);
it.effect("puts the author a query names exactly ahead of those it only begins", () =>
Effect.gen(function* () {
const queries: Array<string | undefined> = [];
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
searchRepositoryAuthors: (input) => {
queries.push(input.query);
return Effect.succeed({
items: [
{ login: "theo-browne", name: null, avatarUrl: null },
{ login: "octocat", name: "Theo", avatarUrl: null },
{ login: "julius", name: "Julius", avatarUrl: null },
{ login: "t3dotgg", name: "theo", avatarUrl: null },
],
truncated: true,
});
},
}),
],
});
const result = yield* service.filterOptions({ kind: "authors", query: "theo" });
assert.deepStrictEqual(queries, ["theo"]);
assert.deepStrictEqual(
result.authors.map((author) => author.login),
["octocat", "t3dotgg", "theo-browne"],
);
assert.strictEqual(result.truncated, true);
}),
);
it.effect("ranks references by number, keeping the host's recent-first order", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
project({ id: "p2", title: "tree", workspaceRoot: "/b", repository: "pingdotgg/t3code" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
searchRepositoryReferences: () =>
Effect.succeed({
items: [
{ reference: "#129", kind: "issue", number: 129, title: "Newest", state: "open" },
{
reference: "#7",
kind: "issue",
number: 7,
title: "Fix #12 again",
state: "open",
},
{
reference: "#12",
kind: "change-request",
number: 12,
title: "Exact",
state: "merged",
},
{ reference: "#120", kind: "issue", number: 120, title: "Older", state: "closed" },
],
truncated: false,
}),
}),
],
});
const result = yield* service.filterOptions({ kind: "references", query: "12" });
assert.deepStrictEqual(
result.references.map((candidate) => candidate.reference),
["#12", "#129", "#120", "#7"],
);
}),
);
it.effect("tries another workspace on the same host for the viewer", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "broken", workspaceRoot: "/broken", repository: "acme/one" }),
project({ id: "p2", title: "healthy", workspaceRoot: "/healthy", repository: "acme/two" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getViewer: (input) =>
input.cwd === "/healthy"
? Effect.succeed("bilal")
: Effect.fail(unusable(SourceControlProviderKind.make("github"), "missing-tool")),
listChangeRequests: () =>
Effect.succeed({
items: [changeRequest(1, "2026-07-02T00:00:00Z")],
truncated: false,
continues: true,
}),
}),
],
});
const result = yield* service.list({ state: "open" });
assert.strictEqual(result.entries.length, 2);
assert.strictEqual(result.viewers["github.com"], "bilal");
}),
);
it.effect("routing verifies the current account on the requested host without caching it", () =>
Effect.gen(function* () {
let viewer = "first-account";
const service = yield* makeService({
projects: [
project({
id: "p1",
title: "web",
workspaceRoot: "/a",
repository: "acme/web",
host: "github.example.test",
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getRoutingIdentity: (input) => {
assert.deepStrictEqual(input, { cwd: "/a", host: "github.example.test" });
return Effect.succeed({
viewer,
accountId: viewer === "first-account" ? "123" : "456",
});
},
}),
],
});
const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
assert.deepStrictEqual(yield* service.routing(ref), {
host: "github.example.test",
provider: SourceControlProviderKind.make("github"),
viewer: "first-account",
accountId: "123",
projectTitle: "web",
workspaceRoot: "/a",
});
viewer = "second-account";
assert.strictEqual((yield* service.routing(ref)).viewer, "second-account");
viewer = " ";
const failure = yield* service.routing(ref).pipe(Effect.flip);
assert.strictEqual(failure._tag, "PullRequestOperationError");
if (failure._tag === "PullRequestOperationError") {
assert.strictEqual(failure.operation, "routeIdentity");
}
}),
);
it.effect("refuses an action the host never claimed it could run", () =>
Effect.gen(function* () {
let ran = false;
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
capabilities: {
diff: true,
comment: true,
actions: ["merge", "close"],
mergeMethods: ["merge"],
search: true,
reactions: true,
review: FULL_REVIEW,
reviewers: FULL_REVIEWERS,
},
runAction: () => {
ran = true;
return Effect.void;
},
}),
],
});
const error = yield* Effect.flip(
service.runAction({
projectId: "p1" as ProjectId,
repository: "acme/web",
number: 1,
action: "reopen",
}),
);
assert.strictEqual(error._tag, "PullRequestOperationError");
assert.isFalse(ran);
}),
);
it.effect(
"asks to remove agent credits on merge only from a host that rewrites merge messages",
() =>
Effect.gen(function* () {
const asked: Array<boolean | undefined> = [];
const runAction: PullRequestProviderApi["runAction"] = (input) =>
Effect.sync(() => {
asked.push(input.removeAgentCreditsOnMerge);
});
for (const rewrites of [true, false]) {
const service = yield* makeService({
settings: { ...DEFAULT_SERVER_SETTINGS, removeAgentCreditsOnMerge: true },
projects: [
project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
runAction,
getChangeRequestSummary: () =>
Effect.succeed(changeRequest(1, "2026-09-03T00:00:00Z")),
...(rewrites ? { mergeMessageRewrite: (message: string) => message } : {}),
}),
],
});
yield* service.runAction({
projectId: "p1" as ProjectId,
repository: "acme/web",
number: 1,
action: "merge",
});
}
assert.deepStrictEqual(asked, [true, undefined]);
}),
);
it.effect("publishes a merge for immediate settlement only after host confirmation", () =>
Effect.scoped(
Effect.gen(function* () {
const mergedAt = "2026-09-03T02:00:00.000Z";
let state: "open" | "merged" = "open";
let confirmationFails = false;
const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
const service = yield* makeService({
projects: [
project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getChangeRequestSummary: () =>
confirmationFails
? Effect.fail(
new PullRequestProviderError({
provider: SourceControlProviderKind.make("github"),
operation: "getChangeRequestSummary",
reason: "failed",
detail: "HTTP 504",
}),
)
: Effect.succeed({ ...changeRequest(1, mergedAt), state, mergedAt }),
}),
],
});
const merges = yield* service.subscribeMerges;
const observedMerge = yield* Stream.runHead(merges).pipe(
Effect.forkChild({ startImmediately: true }),
);
assert.isUndefined(yield* service.runAction({ ...reference, action: "merge" }));
const queuedRefresh = Option.getOrThrow(yield* Stream.runHead(service.subscribeRefreshes));
confirmationFails = true;
yield* service.runAction({ ...reference, action: "merge" });
assert.isAbove(
Option.getOrThrow(yield* Stream.runHead(service.subscribeRefreshes)),
queuedRefresh,
);
confirmationFails = false;
state = "merged";
// The event carries the host's merge time, not the moment the confirmation ran.
yield* TestClock.setTime(Date.parse(mergedAt) + 60_000);
yield* service.runAction({
...reference,
repository: " ACME/WEB ",
action: "merge",
mergeMethod: "merge",
});
assert.deepStrictEqual(Option.getOrThrow(yield* Fiber.join(observedMerge)), {
...reference,
mergedAt,
});
}),
),
);
it.effect("returns the host's merged reply as a summary and trusts it without another read", () =>
Effect.scoped(
Effect.gen(function* () {
const mergedAt = "2026-09-03T02:00:00.000Z";
const merged = {
number: 1,
title: "Change request 1",
url: "https://host/pull/1",
headBranch: "feat/1",
baseBranch: "main",
state: "merged" as const,
isDraft: false,
updatedAt: mergedAt,
mergedAt,
headSha: "abc123",
autoMergeEnabled: false,
};
let summaryReads = 0;
const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
const service = yield* makeService({
projects: [
project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
runAction: () => Effect.succeed(merged),
getChangeRequestSummary: () =>
Effect.sync(() => {
summaryReads++;
return { ...changeRequest(1, mergedAt), state: "merged" as const, mergedAt };
}),
}),
],
});
const merges = yield* service.subscribeMerges;
const observedMerge = yield* Stream.runHead(merges).pipe(
Effect.forkChild({ startImmediately: true }),
);
const observedAt = Date.parse("2026-09-03T02:00:01.000Z");
yield* TestClock.setTime(observedAt);
// Clients that did not ask decode the success as void, so they must get nothing back.
assert.isUndefined(yield* service.runAction({ ...reference, action: "merge" }));
const result = yield* service.runAction({
...reference,
action: "merge",
replyWithSummary: true,
});
assert.deepStrictEqual(result, {
...merged,
provider: SourceControlProviderKind.make("github"),
projectId: reference.projectId,
repository: reference.repository,
observedAt,
});
assert.strictEqual(summaryReads, 0);
assert.deepStrictEqual(Option.getOrThrow(yield* Fiber.join(observedMerge)), {
...reference,
mergedAt,
});
}),
),
);
it.effect("refreshes every reader before a queued merge confirmation finishes", () =>
Effect.scoped(
Effect.gen(function* () {
const confirmationStarted = yield* Deferred.make<void>();
const confirm = yield* Deferred.make<void>();
const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
const service = yield* makeService({
projects: [
project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getChangeRequestSummary: () =>
Effect.gen(function* () {
yield* Deferred.succeed(confirmationStarted, undefined);
yield* Deferred.await(confirm);
return changeRequest(1, "2026-09-16T00:00:00.000Z");
}),
}),
],
});
const merges = yield* service.subscribeMerges;
const observedMerge = yield* Stream.runHead(merges).pipe(
Effect.forkChild({ startImmediately: true }),
);
const readers = yield* Effect.forEach([0, 1], () =>
Stream.runHead(service.subscribeRefreshes).pipe(
Effect.forkChild({ startImmediately: true }),
),
);
const action = yield* service
.runAction({ ...reference, action: "merge" })
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.await(confirmationStarted);
const revisions = yield* Effect.forEach(readers, (reader) =>
Fiber.join(reader).pipe(Effect.map(Option.getOrThrow)),
);
assert.isAbove(revisions[0]!, 0);
assert.strictEqual(revisions[0], revisions[1]);
assert.isUndefined(action.pollUnsafe());
yield* Deferred.succeed(confirm, undefined);
yield* Fiber.join(action);
assert.isUndefined(observedMerge.pollUnsafe());
}),
),
);
it.effect("runs branch deletion only when the host and viewer support it, never for a stack", () =>
Effect.gen(function* () {
let actions = 0;
let supported = false;
let allowed = true;
const base = fakePullRequestProvider(SourceControlProviderKind.make("github"));
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
providers: [
{
...base,
capabilities: {
...base.capabilities,
actions: ["delete-branch"],
stackActions: true,
get deleteBranch() {
return supported;
},
},
getViewerPermissions: () =>
Effect.succeed({
actions: allowed ? ["delete-branch"] : [],
comment: true,
resolve: true,
verdicts: [],
requestReviewers: false,
}),
runAction: (input) =>
Effect.sync(() => {
assert.strictEqual(input.action, "delete-branch");
actions++;
}),
},
],
});
const input = {
projectId: "p1" as ProjectId,
repository: "acme/web",
number: 1,
action: "delete-branch" as const,
};
assert.strictEqual(
(yield* Effect.flip(service.runAction(input)))._tag,
"PullRequestOperationError",
);
assert.strictEqual(actions, 0);
supported = true;
assert.strictEqual(
(yield* Effect.flip(
service.runAction({
...input,
stackNumber: 2,
expectedStackHeads: [{ number: 1, headSha: "abc123" }],
}),
))._tag,
"PullRequestOperationError",
);
assert.strictEqual(actions, 0);
allowed = false;
assert.strictEqual(
(yield* Effect.flip(service.runAction(input)))._tag,
"PullRequestOperationError",
);
assert.strictEqual(actions, 0);
allowed = true;
yield* service.runAction(input);
assert.strictEqual(actions, 1);
}),
);
it.effect("checks and deletes a branch inside one verified credential", () =>
Effect.gen(function* () {
let pinned = false;
const calls: Array<string> = [];
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
capabilities: {
...fakePullRequestProvider("github").capabilities,
actions: ["delete-branch"],
deleteBranch: true,
},
withVerifiedCredential: (_, use) =>
Effect.suspend(() => {
pinned = true;
return use({ accountId: "101", viewer: "bilal", credentialFingerprint: "a" });
}).pipe(Effect.ensuring(Effect.sync(() => (pinned = false)))),
getViewerPermissions: () =>
Effect.sync(() => {
calls.push(`permissions pinned=${pinned}`);
return {
actions: ["delete-branch"],
comment: true,
resolve: true,
verdicts: [],
requestReviewers: false,
};
}),
runAction: (input) =>
Effect.sync(() => {
calls.push(`${input.action} pinned=${pinned}`);
}),
}),
],
});
yield* service.runAction({
projectId: "p1" as ProjectId,
repository: "acme/web",
number: 1,
action: "delete-branch",
});
assert.deepStrictEqual(calls, ["permissions pinned=true", "delete-branch pinned=true"]);
}),
);
it.effect("refuses an action this viewer may not take, and says what access it takes", () =>
Effect.gen(function* () {
let ran: string | null = null;
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getViewerPermissions: () =>
Effect.succeed({
actions: ["ready", "draft", "close", "reopen"],
comment: true,
resolve: true,
verdicts: ["comment", "approve", "request-changes"],
requestReviewers: false,
}),
runAction: (input) => {
ran = input.action;
return Effect.void;
},
}),
],
});
const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
const error = yield* Effect.flip(service.runAction({ ...reference, action: "merge" }));
assert.strictEqual(error._tag, "PullRequestOperationError");
assert.include(error.message, "You need write access on this repository to merge.");
assert.strictEqual(ran, null);
yield* service.runAction({ ...reference, action: "close" });
assert.strictEqual(ran, "close");
}),
);
it.effect("gates arming a merge for later exactly as it gates merging now", () =>
Effect.gen(function* () {
let ranWith: { readonly action: string; readonly mergeMethod?: string } | null = null;
const service = yield* makeService({
projects: [project({ id: "p1", title: "web", workspaceRoot: "/a", repository: "acme/web" })],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
capabilities: {
diff: true,
comment: true,
actions: ["merge", "close", "enable-auto-merge", "disable-auto-merge"],
mergeMethods: ["merge", "squash"],
search: true,
reactions: true,
review: FULL_REVIEW,
reviewers: FULL_REVIEWERS,
},
getViewerPermissions: () =>
Effect.succeed({
actions: ["close"],
comment: true,
resolve: true,
verdicts: ["comment", "approve", "request-changes"],
requestReviewers: false,
}),
runAction: (input) => {
ranWith = {
action: input.action,
...(input.mergeMethod === undefined ? {} : { mergeMethod: input.mergeMethod }),
};
return Effect.void;
},
}),
],
});
const reference = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
const refused = yield* Effect.flip(
service.runAction({ ...reference, action: "enable-auto-merge", mergeMethod: "squash" }),
);
assert.strictEqual(refused._tag, "PullRequestOperationError");
assert.include(refused.message, "the repository has to allow it");
assert.strictEqual(ranWith, null);
const wrongStrategy = yield* Effect.flip(
service.runAction({ ...reference, action: "enable-auto-merge", mergeMethod: "rebase" }),
);
assert.strictEqual(wrongStrategy._tag, "PullRequestOperationError");
assert.strictEqual(ranWith, null);
}),
);
it.effect("keeps two hosts of one provider kind as two accounts", () =>
Effect.gen(function* () {
const viewerFor: Record<string, string> = { "/cloud": "bilal", "/enterprise": "b.hassan" };
const service = yield* makeService({
projects: [
project({ id: "p1", title: "cloud", workspaceRoot: "/cloud", repository: "acme/web" }),
project({
id: "p2",
title: "enterprise",
workspaceRoot: "/enterprise",
repository: "acme/web",
host: "github.acme.dev",
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
getViewer: (input) => Effect.succeed(viewerFor[input.cwd] ?? "unknown"),
listChangeRequests: () =>
Effect.succeed({
items: [changeRequest(1, "2026-07-02T00:00:00Z")],
truncated: false,
continues: true,
}),
}),
],
});
const result = yield* service.list({ state: "open" });
assert.strictEqual(result.entries.length, 2);
assert.deepStrictEqual(result.viewers, {
"github.com": "bilal",
"github.acme.dev": "b.hassan",
});
assert.deepStrictEqual(result.entries.map((entry) => entry.host).toSorted(), [
"github.acme.dev",
"github.com",
]);
}),
);
it.effect("stops new reads after a rate limit while leaving manual actions available", () =>
Effect.gen(function* () {
let listCalls = 0;
let actionCalls = 0;
const service = yield* makeService({
projects: [
project({ id: "p1", title: "cloud", workspaceRoot: "/cloud", repository: "acme/web" }),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("github"), {
listChangeRequests: () =>
Effect.sync(() => {
listCalls += 1;
}).pipe(
Effect.andThen(
Effect.fail(
new PullRequestProviderError({
provider: SourceControlProviderKind.make("github"),
operation: "listChangeRequests",
reason: "rate-limited",
detail: "GitHub API rate limit exceeded.",
}),
),
),
),
runAction: () =>
Effect.sync(() => {
actionCalls += 1;
}),
}),
],
});
const first = yield* service.list({ state: "open", involvement: "all" });
const paused = yield* service.list({ state: "open", involvement: "authored" });
yield* service.runAction({
projectId: "p1" as ProjectId,
repository: "acme/web",
number: 1,
action: "close",
});
assert.strictEqual(listCalls, 1);
assert.strictEqual(actionCalls, 1);
assert.lengthOf(first.errors, 1);
assert.lengthOf(paused.errors, 1);
}),
);
it.effect("refuses a repository that does not belong to the requested project", () =>
Effect.gen(function* () {
const service = yield* makeService({
projects: [
project({ id: "p1", title: "t3code", workspaceRoot: "/a", repository: "pingdotgg/t3code" }),
],
providers: [fakePullRequestProvider(SourceControlProviderKind.make("github"))],
});
const error = yield* service
.diff({ projectId: "p1" as ProjectId, repository: "attacker/repo", number: 1 })
.pipe(Effect.flip);
assert.strictEqual(error._tag, "PullRequestOperationError");
}),
);
it.effect("routes explicit Forgejo HTTP authorities through SSH checkouts after refinement", () =>
Effect.gen(function* () {
for (const provider of ["forgejo", "unknown"] as const) {
const seen: string[] = [];
const viewers: Array<string | undefined> = [];
const service = yield* makeService({
projects: [
project({
id: "ssh",
title: "ssh",
workspaceRoot: "/ssh",
repository: "team/repo",
provider,
host: "ssh.code.example",
remoteUrl: "git@ssh.code.example:team/repo.git",
}),
],
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("forgejo"), {
getViewer: (input) => {
viewers.push(input.host);
assert.strictEqual(input.host, "code.example:3000");
return Effect.succeed("bilal");
},
listChangeRequests: (input) => {
assert.strictEqual(input.host, "code.example:3000");
return Effect.succeed({ items: [], truncated: false, continues: true });
},
getChangeRequest: (input) => {
assert.strictEqual(input.host, "code.example:3000");
return Effect.succeed({ ...hostedChangeRequest("Forgejo detail"), number: 42 });
},
getChangeRequestSummary: (input) =>
Effect.sync(() => {
seen.push(input.host);
return changeRequest(42, "2026-07-02T00:00:00Z");
}),
}),
],
resolveHandle: ({ context }) => {
if (context?.requestedHost === undefined) {
return Effect.succeed({ context: context!, provider: undefined as never });
}
assert.strictEqual(context.requestedHost, "code.example:3000");
return Effect.succeed({
context: {
...context,
provider: {
kind: SourceControlProviderKind.make("forgejo"),
name: "Forgejo",
baseUrl: "http://code.example:3000",
},
},
provider: undefined as never,
});
},
});
yield* service.summary(
{
projectId: "ssh" as ProjectId,
host: "code.example:3000",
repository: "team/repo",
number: 42,
},
{ recoverTransientFailure: false },
);
assert.deepStrictEqual(seen, ["code.example:3000"]);
const listed = yield* service.list({
projectId: "ssh" as ProjectId,
host: "code.example:3000",
state: "open",
});
assert.strictEqual(listed.viewers["code.example:3000"], "bilal");
const preview = yield* service.preview({
projectId: "ssh" as ProjectId,
host: "code.example:3000",
repository: "team/repo",
number: 42,
});
assert.strictEqual(preview.number, 42);
const detail = yield* service.detail({
projectId: "ssh" as ProjectId,
host: "code.example:3000",
repository: "team/repo",
number: 42,
});
assert.strictEqual(detail.body, "Forgejo detail");
assert.deepStrictEqual(viewers, ["code.example:3000"]);
}
}),
);
it.effect("names an SSH remote's web host from a later checkout when the first cannot", () =>
Effect.gen(function* () {
const hosts: Array<string> = [];
const service = yield* makeService({
projects: ["/first", "/second"].map((workspaceRoot, index) =>
project({
id: `p${index}`,
title: `checkout ${index}`,
workspaceRoot,
repository: "team/repo",
provider: SourceControlProviderKind.make("forgejo"),
host: "ssh.code.example",
remoteUrl: "git@ssh.code.example:team/repo.git",
}),
),
providers: [
fakePullRequestProvider(SourceControlProviderKind.make("forgejo"), {
listChangeRequests: (input) => {
hosts.push(input.host);
return Effect.succeed({ items: [], truncated: false, continues: true });
},
}),
],
resolveHandle: ({ cwd, context }) =>
Effect.succeed({
context:
cwd === "/first"