sailfork / t3code-github / apps/ server/ src/ pullRequest/ PullRequestService.test.ts

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"