@gitkraken/core-gitlens 0.4.0 → 0.4.100

package/src/plus/git-github/api/github.ts

@@ -13,7 +13,7 @@ import type { Account, UnidentifiedAuthor } from '../../../git/models/author.js'
 import type { DefaultBranch } from '../../../git/models/defaultBranch.js';
 import type { Issue, IssueShape } from '../../../git/models/issue.js';
 import type { IssueOrPullRequest } from '../../../git/models/issueOrPullRequest.js';
-import type { PullRequest } from '../../../git/models/pullRequest.js';
+import type { PullRequest, PullRequestState, PullRequestStateFilter } from '../../../git/models/pullRequest.js';
 import { PullRequestMergeMethod } from '../../../git/models/pullRequest.js';
 import type { Provider } from '../../../git/models/remoteProvider.js';
 import type { RepositoryMetadata } from '../../../git/models/repositoryMetadata.js';
@@ -27,6 +27,7 @@ import {
 	isRevisionRange,
 	isSha,
 } from '../../../git/utils/revision.utils.js';
+import { chunk } from '../../../utils/array.js';
 import { base64 } from '../../../utils/base64.js';
 import { CancellationError } from '../../../utils/cancellation.js';
 import { trace } from '../../../utils/decorators/log.js';
@@ -55,6 +56,7 @@ import type {
 	GitHubPullRequest,
 	GitHubPullRequestLite,
 	GitHubPullRequestState,
+	GitHubSshSigningKey,
 	GitHubTag,
 } from '../models.js';
 import {
@@ -78,6 +80,9 @@ const maxRequestRetries = 2;
 const requestRetryBaseDelay = 300; // ms
 const requestRetryMaxDelay = 2000; // ms
 
+/** How many email->login user searches to alias into a single GraphQL request (keeps query cost within limits). */
+const accountResolveBatchSize = 25;
+
 function isRetryableTransientError(ex: unknown): ex is RequestError {
 	// An aborted request is rethrown as the original `AbortError` (not a `RequestError`), so it is
 	// excluded here. octokit maps a fetch/network failure to a `RequestError` with status 500 and
@@ -96,6 +101,31 @@ function isRetryableTransientError(ex: unknown): ex is RequestError {
 	}
 }
 
+/**
+ * When a rate-limited request may be retried, as a UTC epoch in seconds, or `undefined` when the response says
+ * nothing useful. Header precedence follows GitHub's own guidance
+ * (docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api): `retry-after` wins when present —
+ * it is the only one a secondary limit reliably sets — and `x-ratelimit-reset` covers the primary limit.
+ */
+function rateLimitResetAt(ex: RequestError): number | undefined {
+	const headers = ex.response?.headers;
+	if (headers == null) return undefined;
+
+	// `retry-after` is a delay in seconds, not an epoch, so it has to be added to now to compare with `resetAt`.
+	const retryAfter = toPositiveInt(headers['retry-after']);
+	if (retryAfter != null) return Math.floor(Date.now() / 1000) + retryAfter;
+
+	return toPositiveInt(headers['x-ratelimit-reset']);
+}
+
+function toPositiveInt(value: string | number | undefined): number | undefined {
+	if (value == null) return undefined;
+
+	const parsed = typeof value === 'number' ? value : parseInt(value, 10);
+	// Rejects NaN and a nonsensical negative/zero, either of which would present as an already-elapsed reset.
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
 function getRequestRetryDelay(attempt: number): number {
 	// Exponential backoff with equal jitter, capped — spreads retries so a brief upstream blip
 	// isn't hammered by every in-flight request landing on the same schedule.
@@ -127,15 +157,18 @@ author {
 	avatarUrl(size: $avatarSize)
 	url
 }
+body
 baseRefName
 baseRefOid
 headRefName
 headRefOid
 headRepository {
+	isFork
 	name
 	owner {
 		login
 	}
+	sshUrl
 	url
 }
 isCrossRepository
@@ -148,6 +181,7 @@ repository {
 	owner {
 		login
 	}
+	sshUrl
 	url
 	viewerPermission
 }
@@ -549,6 +583,61 @@ export class GitHubApi {
 		}
 	}
 
+	@trace({ args: (provider, token) => ({ provider: provider?.name, token: `<token:${token.microHash}>` }) })
+	async getAccountsForEmails(
+		provider: Provider,
+		token: GitHubTokenInfo,
+		emails: string[],
+		options?: { baseUrl?: string },
+	): Promise<Map<string, string>> {
+		const scope = getScopedLogger();
+
+		// Resolves email -> login for many emails in one request via field aliasing, chunked to keep query cost within
+		// GitHub's limits. Each email is passed as a GraphQL variable (never interpolated into the query string) so an
+		// attacker-controllable commit email can't inject query structure. Keyed by lowercased email.
+		//
+		// This is intentionally best-effort: user-by-email search only matches accounts whose email is public, and the
+		// search API is subject to GitHub's separate search/secondary rate limits, so misses and per-batch failures are
+		// expected and tolerated. GitHub noreply addresses (the common case) are decoded locally by the caller without
+		// hitting this at all.
+		const result = new Map<string, string>();
+		if (emails.length === 0) return result;
+
+		interface QueryResult {
+			[alias: string]: { nodes?: ({ login: string | null } | null)[] | null } | null | undefined;
+		}
+
+		for (const batch of chunk(emails, accountResolveBatchSize)) {
+			const declarations = batch.map((_, i) => `$q${i}: String!`).join(', ');
+			const fields = batch
+				.map((_, i) => `e${i}: search(type: USER, query: $q${i}, first: 1) { nodes { ... on User { login } } }`)
+				.join('\n\t');
+			const query = `query getAccountsForEmails(${declarations}) {\n\t${fields}\n}`;
+
+			const variables: RequestParameters = { ...options };
+			batch.forEach((email, i) => {
+				variables[`q${i}`] = `in:email ${email}`;
+			});
+
+			try {
+				const rsp = await this.graphql<QueryResult>(provider, token, query, variables, scope);
+				if (rsp == null) continue;
+
+				batch.forEach((email, i) => {
+					const login = rsp[`e${i}`]?.nodes?.[0]?.login;
+					if (login) {
+						result.set(email.toLowerCase(), login);
+					}
+				});
+			} catch (ex) {
+				// Best-effort enrichment — a failed batch (e.g. query cost) shouldn't abort the others.
+				scope?.error(ex);
+			}
+		}
+
+		return result;
+	}
+
 	@trace({
 		args: (provider, token, owner, repo) => ({
 			provider: provider.name,
@@ -810,7 +899,7 @@ export class GitHubApi {
 ) {
 	repository(name: $repo, owner: $owner) {
 		pullRequest(number: $number) {
-			${gqlPullRequestFragment}
+			${gqlPullRequestLiteFragment}
 		}
 	}
 }`;
@@ -2338,6 +2427,64 @@ export class GitHubApi {
 		}
 	}
 
+	@trace({
+		args: (provider, token, username) => ({
+			provider: provider?.name,
+			token: `<token:${token.microHash}>`,
+			username: username,
+		}),
+	})
+	async getUserSshSigningKeys(
+		provider: Provider | undefined,
+		token: GitHubTokenInfo,
+		username: string,
+		options?: { baseUrl?: string },
+	): Promise<GitHubSshSigningKey[]> {
+		const scope = getScopedLogger();
+
+		// SSH signing keys are public, so this works for any user with the current token (no extra scope needed).
+		// TODO@eamodio implement pagination
+		try {
+			const rsp = await this.request(
+				provider,
+				token,
+				'GET /users/{username}/ssh_signing_keys',
+				{ username: username, per_page: 100, ...options },
+				scope,
+			);
+			return rsp?.data ?? [];
+		} catch (ex) {
+			if (ex instanceof RequestNotFoundError) return [];
+
+			throw this.handleException(ex, provider, scope);
+		}
+	}
+
+	@trace({ args: (provider, token) => ({ provider: provider?.name, token: `<token:${token.microHash}>` }) })
+	async getCurrentUserSshSigningKeys(
+		provider: Provider | undefined,
+		token: GitHubTokenInfo,
+		options?: { baseUrl?: string },
+	): Promise<GitHubSshSigningKey[]> {
+		const scope = getScopedLogger();
+
+		// TODO@eamodio implement pagination
+		try {
+			const rsp = await this.request(
+				provider,
+				token,
+				'GET /user/ssh_signing_keys',
+				{ per_page: 100, ...options },
+				scope,
+			);
+			return rsp?.data ?? [];
+		} catch (ex) {
+			if (ex instanceof RequestNotFoundError) return [];
+
+			throw this.handleException(ex, provider, scope);
+		}
+	}
+
 	@trace({ args: (token, owner, repo) => ({ token: `<token:${token.microHash}>`, owner: owner, repo: repo }) })
 	async getDefaultBranchName(token: GitHubTokenInfo, owner: string, repo: string): Promise<string | undefined> {
 		const scope = getScopedLogger();
@@ -3172,22 +3319,18 @@ export class GitHubApi {
 			case 410: // Gone
 			case 422: // Unprocessable Entity
 				throw new RequestNotFoundError(ex);
-			// case 429: //Too Many Requests
+			case 429: // Too Many Requests
+				// GitHub returns "a `403` or `429` response" for BOTH its primary and secondary rate limits
+				// (docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api). 429 is unambiguous —
+				// unlike 403, it is never a permission failure — so it needs no message check.
+				throw new RequestRateLimitError(ex, accessToken, rateLimitResetAt(ex));
 			case 401: // Unauthorized
 				throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Unauthorized, ex);
 			case 403: // Forbidden
+				// The other status the rate limits arrive on, but 403 is also a plain permission failure, so here
+				// the message is the discriminant.
 				if (ex.message.includes('rate limit')) {
-					let resetAt: number | undefined;
-
-					const reset = ex.response?.headers?.['x-ratelimit-reset'];
-					if (reset != null) {
-						resetAt = parseInt(reset, 10);
-						if (Number.isNaN(resetAt)) {
-							resetAt = undefined;
-						}
-					}
-
-					throw new RequestRateLimitError(ex, accessToken, resetAt);
+					throw new RequestRateLimitError(ex, accessToken, rateLimitResetAt(ex));
 				}
 				throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Forbidden, ex);
 			case 500: // Internal Server Error
@@ -3307,7 +3450,7 @@ export class GitHubApi {
 	}
 
 	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
-	async searchMyPullRequests(
+	async searchMyPullRequestsPage(
 		provider: Provider,
 		token: GitHubTokenInfo,
 		options?: {
@@ -3317,40 +3460,54 @@ export class GitHubApi {
 			baseUrl?: string;
 			avatarSize?: number;
 			silent?: boolean;
+			state?: PullRequestStateFilter;
+			cursor?: string;
+			/**
+			 * Uses the lightweight PR fragment while retaining identity, body, author, repository, and branch refs.
+			 * Intended for aggregate/list surfaces that do not consume review, check, or diff statistics.
+			 */
+			summary?: boolean;
+			/**
+			 * Adds GitHub's provider-native `involves:@me` relationship. Disable when `search` already carries
+			 * an explicit relationship qualifier such as `author:@me` or `review-requested:@me`.
+			 */
+			includeDefaultInvolvement?: boolean;
 		},
 		cancellation?: AbortSignal,
-	): Promise<PullRequest[]> {
+	): Promise<{ values: PullRequest[]; cursor?: string; hasMore: boolean; truncated: boolean }> {
 		const scope = getScopedLogger();
-
 		const limit = Math.min(100, this.config.getLaunchpadQueryLimit?.() ?? 100);
 
 		try {
 			interface SearchResult {
 				search: {
 					issueCount: number;
+					pageInfo: {
+						endCursor?: string | null;
+						hasNextPage: boolean;
+					};
 					nodes: GitHubPullRequest[];
 				};
-				viewer: {
-					login: string;
-				};
 			}
 
 			const query = `query searchMyPullRequests(
-	$search: String!
-	$avatarSize: Int
-) {
-	search(first: ${limit}, query: $search, type: ISSUE) {
-		issueCount
-		nodes {
-			...on PullRequest {
-				${gqlPullRequestFragment}
+		$search: String!
+		$cursor: String
+		$avatarSize: Int
+	) {
+		search(first: ${limit}, after: $cursor, query: $search, type: ISSUE) {
+			issueCount
+			pageInfo {
+				endCursor
+				hasNextPage
+			}
+			nodes {
+				...on PullRequest {
+					${options?.summary ? gqlPullRequestLiteFragment : gqlPullRequestFragment}
+				}
 			}
 		}
-	}
-	viewer {
-		login
-	}
-}`;
+	}`;
 
 			let search = options?.search?.trim() ?? '';
 
@@ -3362,65 +3519,81 @@ export class GitHubApi {
 				search += ` repo:${options.repos.join(' repo:')}`;
 			}
 
-			// Hack for now, ultimately this should be passed in
 			const ignoredRepos = this.config.getLaunchpadIgnoredRepositories?.() ?? [];
 			if (ignoredRepos.length) {
 				search += ` -repo:${ignoredRepos.join(' -repo:')}`;
 			}
 
-			// Hack for now, ultimately this should be passed in
 			const enabledOrgs = this.config.getLaunchpadIncludedOrganizations?.() ?? [];
 			if (enabledOrgs.length) {
 				search += ` org:${enabledOrgs.join(' org:')}`;
 			} else {
-				// Hack for now, ultimately this should be passed in
 				const ignoredOrgs = this.config.getLaunchpadIgnoredOrganizations?.() ?? [];
 				if (ignoredOrgs.length) {
 					search += ` -org:${ignoredOrgs.join(' -org:')}`;
 				}
 			}
 
+			const stateQualifier =
+				options?.state === 'closed'
+					? 'is:closed is:unmerged'
+					: options?.state === 'merged'
+						? 'is:merged'
+						: options?.state === 'all'
+							? ''
+							: 'is:open';
+
+			const relationshipQualifier =
+				options?.includeDefaultInvolvement === false
+					? 'is:pr archived:false'
+					: 'is:pr involves:@me archived:false';
 			const rsp = await this.graphql<SearchResult>(
 				provider,
 				token,
 				query,
 				{
-					search: `is:open is:pr involves:@me archived:false ${search}`.trim(),
+					search: [stateQualifier, relationshipQualifier, search].filter(Boolean).join(' ').trim(),
+					cursor: options?.cursor,
 					baseUrl: options?.baseUrl,
 					avatarSize: options?.avatarSize,
 				},
 				scope,
 				cancellation,
 			);
-			if (rsp == null) return [];
-
-			const viewer = rsp.viewer.login;
+			if (rsp == null) return { values: [], hasMore: false, truncated: false };
 
-			function toQueryResult(pr: GitHubPullRequest): PullRequest {
-				const reasons = [];
-				if (pr.author.login === viewer) {
-					reasons.push('authored');
-				}
-				if (pr.assignees.nodes.some(a => a.login === viewer)) {
-					reasons.push('assigned');
-				}
-				if (pr.reviewRequests.nodes.some(r => r.requestedReviewer?.login === viewer)) {
-					reasons.push('review-requested');
-				}
-				if (reasons.length === 0) {
-					reasons.push('mentioned');
-				}
-
-				return fromGitHubPullRequest(pr, provider);
-			}
-
-			const results: PullRequest[] = rsp.search.nodes.map(pr => toQueryResult(pr));
-			return results;
+			const results: PullRequest[] = rsp.search.nodes.map(pr =>
+				options?.summary ? fromGitHubPullRequestLite(pr, provider) : fromGitHubPullRequest(pr, provider),
+			);
+			return {
+				values: results,
+				cursor: rsp.search.pageInfo.endCursor ?? undefined,
+				hasMore: rsp.search.pageInfo.hasNextPage,
+				truncated: rsp.search.issueCount > 1000,
+			};
 		} catch (ex) {
 			throw this.handleException(ex, provider, scope, options?.silent);
 		}
 	}
 
+	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
+	async searchMyPullRequests(
+		provider: Provider,
+		token: GitHubTokenInfo,
+		options?: {
+			search?: string;
+			user?: string;
+			repos?: string[];
+			baseUrl?: string;
+			avatarSize?: number;
+			silent?: boolean;
+			state?: PullRequestStateFilter;
+		},
+		cancellation?: AbortSignal,
+	): Promise<PullRequest[]> {
+		return (await this.searchMyPullRequestsPage(provider, token, options, cancellation)).values;
+	}
+
 	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
 	async searchMyIssues(
 		provider: Provider,
@@ -3432,55 +3605,130 @@ export class GitHubApi {
 			baseUrl?: string;
 			avatarSize?: number;
 			includeBody?: boolean;
+			includeAllAssignees?: boolean;
+			cursor?: string;
+			/**
+			 * Which of the three "my issues" searches to run. Omitted runs all three (GitHub's own definition of
+			 * "mine": authored ∪ assigned ∪ mentioned). Supplied, only the `true` ones run — so a caller wanting
+			 * `assignee:@me` parity asks for `{ assigned: true }` instead of filtering the union client-side (which
+			 * can't work: the dropped items still counted toward this page, so `hasMore`/`cursor` would describe a
+			 * different result set than `values`).
+			 *
+			 * At least one must be `true`; an all-`false` set reads nothing rather than silently widening back to
+			 * the union. The facade never sends one (an empty filter set means "unfiltered" there).
+			 */
+			categories?: { authored?: boolean; assigned?: boolean; mentioned?: boolean };
 		},
 		cancellation?: AbortSignal,
-	): Promise<IssueShape[] | undefined> {
+	): Promise<
+		| {
+				values: IssueShape[];
+				cursor?: string;
+				hasMore: boolean;
+				page: number;
+				truncated: boolean;
+		  }
+		| undefined
+	> {
 		const scope = getScopedLogger();
 
-		interface SearchResult {
-			authored: {
-				nodes: GitHubIssue[];
-			};
-			assigned: {
-				nodes: GitHubIssue[];
-			};
-			mentioned: {
-				nodes: GitHubIssue[];
+		type SearchCategory = {
+			issueCount: number;
+			pageInfo?: {
+				endCursor?: string | null;
+				hasNextPage: boolean;
 			};
+			nodes: GitHubIssue[];
+		};
+		interface SearchResult {
+			authored?: SearchCategory;
+			assigned?: SearchCategory;
+			mentioned?: SearchCategory;
+		}
+		interface SearchCursor {
+			page?: number;
+			authored?: string | null;
+			assigned?: string | null;
+			mentioned?: string | null;
+			truncated?: boolean;
 		}
 
-		const issueFragement = `${gqIssueFragment}${
-			options?.includeBody
-				? `
-			body
-			`
-				: ''
-		}`;
+		let cursor: SearchCursor | undefined;
+		if (options?.cursor != null) {
+			try {
+				cursor = JSON.parse(options.cursor) as SearchCursor;
+			} catch {}
+		}
+		const page = Math.max(1, Math.trunc(cursor?.page ?? 1));
+		// A category is read when the caller asked for it AND it hasn't been exhausted (`null` cursor slot). An
+		// excluded category needs no cursor bookkeeping: `nextCategoryCursor` reads a missing response category as
+		// `null`, so it stays excluded across continuations on its own.
+		const categories = options?.categories;
+		const requested = {
+			authored: categories?.authored ?? categories == null,
+			assigned: categories?.assigned ?? categories == null,
+			mentioned: categories?.mentioned ?? categories == null,
+		};
+		const includeAuthored = requested.authored && cursor?.authored !== null;
+		const includeAssigned = requested.assigned && cursor?.assigned !== null;
+		const includeMentioned = requested.mentioned && cursor?.mentioned !== null;
+		// Reading nothing is the honest answer to "none of the three": widening back to the union would return
+		// issues the caller explicitly excluded.
+		if (!includeAuthored && !includeAssigned && !includeMentioned) {
+			return { values: [], hasMore: false, page: page, truncated: cursor?.truncated === true };
+		}
 
 		const query = `query searchMyIssues(
 				$authored: String!
 				$assigned: String!
 				$mentioned: String!
+				$authoredCursor: String
+				$assignedCursor: String
+				$mentionedCursor: String
+				$includeAuthored: Boolean!
+				$includeAssigned: Boolean!
+				$includeMentioned: Boolean!
 				$avatarSize: Int
 			) {
-				authored: search(first: 100, query: $authored, type: ISSUE) {
+				authored: search(first: 100, after: $authoredCursor, query: $authored, type: ISSUE)
+					@include(if: $includeAuthored) {
+					issueCount
+					pageInfo {
+						endCursor
+						hasNextPage
+					}
 					nodes {
 						... on Issue {
-							${issueFragement}
+							${gqIssueFragment}
+							${options?.includeBody ? 'body' : ''}
 						}
 					}
 				}
-				assigned: search(first: 100, query: $assigned, type: ISSUE) {
+				assigned: search(first: 100, after: $assignedCursor, query: $assigned, type: ISSUE)
+					@include(if: $includeAssigned) {
+					issueCount
+					pageInfo {
+						endCursor
+						hasNextPage
+					}
 					nodes {
 						... on Issue {
-							${issueFragement}
+							${gqIssueFragment}
+							${options?.includeBody ? 'body' : ''}
 						}
 					}
 				}
-				mentioned: search(first: 100, query: $mentioned, type: ISSUE) {
+				mentioned: search(first: 100, after: $mentionedCursor, query: $mentioned, type: ISSUE)
+					@include(if: $includeMentioned) {
+					issueCount
+					pageInfo {
+						endCursor
+						hasNextPage
+					}
 					nodes {
 						... on Issue {
-							${issueFragement}
+							${gqIssueFragment}
+							${options?.includeBody ? 'body' : ''}
 						}
 					}
 				}
@@ -3498,6 +3746,15 @@ export class GitHubApi {
 		}
 
 		const baseFilters = 'type:issue is:open archived:false';
+		// `includeAllAssignees` broadens the assigned category from "assigned to me" to "assigned to anyone"
+		// (`assignee:*` is GitHub's has-any-assignee qualifier). Authored/mentioned stay bound to `@me` — they're
+		// user-relative by definition, so an all-assignees read still only surfaces the current user's authored
+		// and mentioned issues plus every assigned-to-anyone issue.
+		//
+		// NOTE: GitHub only honors `assignee:*` when the search is scoped to a single repository (see GitHub's
+		// issue-search docs). Callers using `includeAllAssignees` must scope the read via `repos` (the broaden
+		// fan-out does this per org/repo); an unscoped account-wide `assignee:*` is not meaningful to GitHub.
+		const assignedQualifier = options?.includeAllAssignees ? 'assignee:*' : 'assignee:@me';
 		try {
 			const rsp = await this.graphql<SearchResult>(
 				provider,
@@ -3505,8 +3762,14 @@ export class GitHubApi {
 				query,
 				{
 					authored: `${search} ${baseFilters} author:@me`.trim(),
-					assigned: `${search} ${baseFilters} assignee:@me`.trim(),
+					assigned: `${search} ${baseFilters} ${assignedQualifier}`.trim(),
 					mentioned: `${search} ${baseFilters} mentions:@me`.trim(),
+					authoredCursor: cursor?.authored ?? undefined,
+					assignedCursor: cursor?.assigned ?? undefined,
+					mentionedCursor: cursor?.mentioned ?? undefined,
+					includeAuthored: includeAuthored,
+					includeAssigned: includeAssigned,
+					includeMentioned: includeMentioned,
 					baseUrl: options?.baseUrl,
 					avatarSize: options?.avatarSize,
 				},
@@ -3518,14 +3781,48 @@ export class GitHubApi {
 				return fromGitHubIssue(issue, provider);
 			}
 
-			if (rsp == null) return [];
+			if (rsp == null) return { values: [], hasMore: false, page: page, truncated: false };
 
 			const results: IterableIterator<IssueShape> = uniqueBy(
-				[...rsp.assigned.nodes, ...rsp.mentioned.nodes, ...rsp.authored.nodes].map(toQueryResult),
+				[...(rsp.assigned?.nodes ?? []), ...(rsp.mentioned?.nodes ?? []), ...(rsp.authored?.nodes ?? [])].map(
+					toQueryResult,
+				),
 				r => r.url,
 				(original, _current) => original,
 			);
-			return [...results];
+
+			const nextCategoryCursor = (category: SearchCategory | undefined): string | null => {
+				if (category?.pageInfo?.hasNextPage && category.pageInfo.endCursor) {
+					return category.pageInfo.endCursor;
+				}
+				return null;
+			};
+			const next: SearchCursor = {
+				page: page + 1,
+				authored: nextCategoryCursor(rsp.authored),
+				assigned: nextCategoryCursor(rsp.assigned),
+				mentioned: nextCategoryCursor(rsp.mentioned),
+			};
+			const hasMore = next.authored != null || next.assigned != null || next.mentioned != null;
+			// GitHub search exposes at most 1,000 results per category. Paging removes the previous 100-item
+			// truncation; only the upstream search ceiling or an unusable continuation remains incomplete.
+			const continuationMissing = [rsp.authored, rsp.assigned, rsp.mentioned].some(
+				category => category?.pageInfo?.hasNextPage === true && category.pageInfo.endCursor == null,
+			);
+			const truncated =
+				cursor?.truncated === true ||
+				(rsp.authored?.issueCount ?? 0) > 1000 ||
+				(rsp.assigned?.issueCount ?? 0) > 1000 ||
+				(rsp.mentioned?.issueCount ?? 0) > 1000 ||
+				continuationMissing;
+			next.truncated = truncated || undefined;
+			return {
+				values: [...results],
+				cursor: hasMore ? JSON.stringify(next) : undefined,
+				hasMore: hasMore,
+				page: page,
+				truncated: truncated,
+			};
 		} catch (ex) {
 			throw this.handleException(ex, provider, scope);
 		}
@@ -3535,13 +3832,27 @@ export class GitHubApi {
 	async searchPullRequests(
 		provider: Provider,
 		token: GitHubTokenInfo,
-		options?: { search?: string; user?: string; repos?: string[]; baseUrl?: string; avatarSize?: number },
+		options?: {
+			search?: string;
+			user?: string;
+			repos?: string[];
+			baseUrl?: string;
+			avatarSize?: number;
+			include?: PullRequestState[];
+		},
 		cancellation?: AbortSignal,
 	): Promise<PullRequest[]> {
 		const scope = getScopedLogger();
+		const pageSize = 10;
+		const include = options?.include?.length ? options.include : undefined;
+		const requiresPagination = shouldPaginateGitHubSearchState(include);
 
 		interface SearchResult {
 			search: {
+				pageInfo: {
+					endCursor?: string | null;
+					hasNextPage: boolean;
+				};
 				nodes: GitHubPullRequest[];
 			};
 		}
@@ -3549,9 +3860,14 @@ export class GitHubApi {
 		try {
 			const query = `query searchPullRequests(
 	$searchQuery: String!
+		$cursor: String
 	$avatarSize: Int
 ) {
-	search(first: 10, query: $searchQuery, type: ISSUE) {
+		search(first: ${pageSize}, after: $cursor, query: $searchQuery, type: ISSUE) {
+			pageInfo {
+				endCursor
+				hasNextPage
+			}
 		nodes {
 			...on PullRequest {
 				${gqlPullRequestFragment}
@@ -3571,22 +3887,44 @@ export class GitHubApi {
 				search += `${repo}${options.repos.join(repo)}`;
 			}
 
-			const rsp = await this.graphql<SearchResult>(
-				provider,
-				token,
-				query,
-				{
-					searchQuery: `is:pr is:open archived:false ${search.trim()}`,
-					baseUrl: options?.baseUrl,
-					avatarSize: options?.avatarSize,
-				},
-				scope,
-				cancellation,
-			);
-			if (rsp == null) return [];
+			const searchQuery = ['is:pr', toGitHubSearchStateQualifier(include), 'archived:false', search.trim()]
+				.filter(Boolean)
+				.join(' ');
+
+			// Bound the paginated case with a defensive page backstop like the other paged provider drains, so a
+			// large, low-match result set can't fan out into an unbounded request loop.
+			const maxSearchPages = 20;
+			let cursor: string | undefined;
+			const results: PullRequest[] = [];
+			for (let page = 0; page < maxSearchPages; page++) {
+				const rsp = await this.graphql<SearchResult>(
+					provider,
+					token,
+					query,
+					{
+						searchQuery: searchQuery,
+						cursor: cursor,
+						baseUrl: options?.baseUrl,
+						avatarSize: options?.avatarSize,
+					},
+					scope,
+					cancellation,
+				);
+				if (rsp == null) return [];
 
-			const results = rsp.search.nodes.map(pr => fromGitHubPullRequest(pr, provider));
-			return results;
+				const pageResults = filterPullRequestsBySearchState(
+					rsp.search.nodes.map(pr => fromGitHubPullRequest(pr, provider)),
+					include,
+				);
+				results.push(...pageResults);
+
+				cursor = rsp.search.pageInfo.endCursor ?? undefined;
+				if (!requiresPagination || results.length >= pageSize || !rsp.search.pageInfo.hasNextPage) {
+					break;
+				}
+			}
+
+			return results.slice(0, pageSize);
 		} catch (ex) {
 			throw this.handleException(ex, provider, scope);
 		}
@@ -3668,3 +4006,45 @@ export class GitHubApi {
 function isGitHubDotCom(options?: { baseUrl?: string }) {
 	return options?.baseUrl == null || options.baseUrl === 'https://api.github.com';
 }
+
+// Translates the requested PR states into a GitHub search state qualifier. GitHub search treats
+// `is:closed` as closed-or-merged, `is:merged` as its subset, and `is:unmerged` as open + closed
+// (not-merged), so `closed` and `merged` (distinct in our model) map to `is:closed is:unmerged` and
+// `is:merged`. `undefined` preserves the historical open-only default.
+export function toGitHubSearchStateQualifier(include: PullRequestState[] | undefined): string {
+	if (include == null) return 'is:open';
+
+	const opened = include.includes('opened');
+	const closed = include.includes('closed');
+	const merged = include.includes('merged');
+
+	if (opened && closed && merged) return ''; // all states -> no qualifier
+	if (opened && closed) return 'is:unmerged';
+	if (closed && merged) return 'is:closed';
+	// `opened && merged` isn't expressible as a single AND qualifier; omit it here and post-filter.
+	if (opened && merged) return '';
+	if (opened) return 'is:open';
+	if (merged) return 'is:merged';
+	if (closed) return 'is:closed is:unmerged';
+	return 'is:open'; // empty include -> default
+}
+
+export function filterPullRequestsBySearchState<T extends { state: PullRequestState }>(
+	pullRequests: T[],
+	include: PullRequestState[] | undefined,
+): T[] {
+	const states = include?.length ? include : (['opened'] satisfies PullRequestState[]);
+	const allowedStates = new Set<PullRequestState>(states);
+	// There are only 3 possible states, so a full set means every state is allowed; use the deduped set
+	// size rather than the raw length so duplicates (e.g. `['opened', 'opened', 'closed']`) don't skip filtering.
+	if (allowedStates.size === 3) return pullRequests;
+
+	return pullRequests.filter(pr => allowedStates.has(pr.state));
+}
+
+function shouldPaginateGitHubSearchState(include: PullRequestState[] | undefined): boolean {
+	if (include == null || include.length === 0) return false;
+
+	const uniqueStates = new Set<PullRequestState>(include);
+	return uniqueStates.size === 2 && uniqueStates.has('opened') && uniqueStates.has('merged');
+}