@gitkraken/core-gitlens 0.4.0 → 0.4.100

package/dist/plus/integrations/models/gitHostIntegration.js

@@ -9,9 +9,56 @@ import { trace } from '../../../utils/decorators/log.js';
 import { first } from '../../../utils/iterable.js';
 import { Logger } from '../../../utils/logger.js';
 import { getScopedLogger } from '../../../utils/logger.scoped.js';
-import { GitCloudHostIntegrationId } from '../constants.js';
-import { IssueFilter, PagingMode, PullRequestFilter } from '../providers/models.js';
+import { toTokenWithInfo } from '../authentication/models.js';
+import { toCollectionScopeFailure } from '../collectionMetadata.js';
+import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId } from '../constants.js';
+import { toError } from '../errors.js';
+import { IssueFilter, PagingMode, PullRequestFilter, toIssueShape, toProviderIssueStates, toProviderPullRequestStates, } from '../providers/models.js';
+import { mergeCollectionMetadata } from '../providers/utils/providerPaging.js';
 import { IntegrationBase } from './integration.js';
+function isAzureDevOpsProvider(providerId) {
+    return (providerId === GitCloudHostIntegrationId.AzureDevOps ||
+        providerId === GitSelfManagedHostIntegrationId.AzureDevOpsServer);
+}
+function normalizeSelfManagedBaseUrl(domain, protocol) {
+    const value = domain?.trim();
+    if (!value)
+        return undefined;
+    if (/^[a-z][a-z\d+\-.]*:\/\//i.test(value)) {
+        try {
+            const url = new URL(value);
+            return `${url.protocol}//${url.host}${url.pathname.replace(/\/+$/, '')}`;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const scheme = protocol ?? 'https:';
+    try {
+        const url = new URL(`${scheme}//${value}`);
+        return `${url.protocol}//${url.host}${url.pathname.replace(/\/+$/, '')}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getSelfManagedApiBaseUrl(providerId, domain, protocol) {
+    const baseUrl = normalizeSelfManagedBaseUrl(domain, protocol);
+    if (baseUrl == null)
+        return undefined;
+    switch (providerId) {
+        case GitSelfManagedHostIntegrationId.CloudGitHubEnterprise:
+            return `${baseUrl.replace(/\/api(?:\/v\d+)?$/, '')}/api/v3`;
+        case GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted:
+            return baseUrl.replace(/\/api(?:\/v\d+)?$/, '');
+        case GitSelfManagedHostIntegrationId.BitbucketServer:
+            return `${baseUrl.replace(/\/rest\/api\/1\.0$/, '')}/rest/api/1.0`;
+        case GitSelfManagedHostIntegrationId.AzureDevOpsServer:
+            return baseUrl;
+        default:
+            return undefined;
+    }
+}
 export class GitHostIntegration extends IntegrationBase {
     type = 'git';
     async getAccountForEmail(repo, email, options) {
@@ -30,6 +77,31 @@ export class GitHostIntegration extends IntegrationBase {
             return undefined;
         }
     }
+    /**
+     * Returns the SSH signing keys (full OpenSSH-format `<type> <key> [comment]` strings) registered by the accounts
+     * matching the given emails on this integration, for building an `allowed_signers` file. Keyed by lowercased email;
+     * emails with no match (and unsupported integrations) are absent. Batching the lookups is left to the integration.
+     */
+    async getSshSigningKeysForEmails(repo, emails) {
+        const scope = getScopedLogger();
+        const connected = this.maybeConnected ?? (await this.isConnected());
+        if (!connected)
+            return new Map();
+        await this.refreshSessionIfExpired(scope);
+        try {
+            const keys = await this.getProviderSshSigningKeysForEmails(this._session, repo, emails);
+            this.resetRequestExceptionCount('getSshSigningKeysForEmails');
+            return keys;
+        }
+        catch (ex) {
+            this.handleProviderException('getSshSigningKeysForEmails', ex, { scope: scope });
+            return new Map();
+        }
+    }
+    /** Override in integrations that expose users' SSH signing keys. Defaults to none. */
+    getProviderSshSigningKeysForEmails(_session, _repo, _emails) {
+        return Promise.resolve(new Map());
+    }
     async getAccountForCommit(repo, rev, options) {
         const scope = getScopedLogger();
         const connected = this.maybeConnected ?? (await this.isConnected());
@@ -88,6 +160,162 @@ export class GitHostIntegration extends IntegrationBase {
         }), { expiryOverride: options?.expiryOverride });
         return metadata;
     }
+    /**
+     * Lists the organizations (orgs/workspaces/groups) the current user belongs to on this host.
+     * `truncated === true` means the defensive page-drain backstop stopped before the upstream listing
+     * was exhausted.
+     */
+    async getOrganizationsForUser() {
+        return (await this.getOrganizationsForUserResult())?.value;
+    }
+    /**
+     * Whether this git host implements generic org discovery. False for providers that register no
+     * {@link getProviderOrganizationsForUser} hook (e.g. Bitbucket Data Center) — the facade uses this to
+     * report `unsupported` instead of a silent empty list, which is indistinguishable from "has no orgs".
+     */
+    get supportsOrganizationDiscovery() {
+        return this.getProviderOrganizationsForUser != null;
+    }
+    /** Whether this git host implements generic repository discovery ({@link getProviderRepositoriesForOrg}). */
+    get supportsRepositoryDiscovery() {
+        return this.getProviderRepositoriesForOrg != null;
+    }
+    /**
+     * Whether this git host has a project tier between org and repo ({@link getProviderProjectsForOrg}). Only
+     * Azure DevOps does; the facade uses this to skip the read entirely rather than call a core that returns
+     * `undefined` for a session-less reason and be misread as a broken connection.
+     */
+    get supportsProjectDiscovery() {
+        return this.getProviderProjectsForOrg != null;
+    }
+    /**
+     * Whether this git host implements the account-wide user-affiliated repository read
+     * ({@link getProviderRepositoriesForUser}) — the org-less `gk provider repos <provider>` equivalent.
+     */
+    get supportsUserRepositoryDiscovery() {
+        return this.getProviderRepositoriesForUser != null;
+    }
+    /**
+     * Whether this git host exposes issues on the ProviderBackend surface. Most git hosts do; a host with no
+     * usable issue tracker overrides this to false — Bitbucket Cloud (deprecated in favor of dedicated issue
+     * integrations like Jira) and Bitbucket Data Center (never had one) — so the facade reports issues as
+     * unsupported instead of serving a partial/deprecated source or failing inside a provider client that
+     * registers no issue function at all.
+     *
+     * Keep this in sync with {@link ProviderMetadata.supportedIssueFilters}: a provider that declares no issue
+     * filters and no issue read is answering the same capability question twice, and the two must agree.
+     */
+    get supportsIssues() {
+        return true;
+    }
+    /**
+     * Result-returning core of {@link getOrganizationsForUser}. Resolves the session for `connectionId`
+     * (or the primary connection when omitted, honoring multi-account reads) and recovers a thrown error
+     * into `{ error }` so callers can surface it as a warning instead of swallowing it to `undefined`.
+     */
+    async getOrganizationsForUserResult(connectionId) {
+        const scope = getScopedLogger();
+        // `connectionId` targets a specific account (multi-account); omitted reads the primary.
+        const session = await this.resolveReadSession(connectionId, scope);
+        if (session == null)
+            return undefined;
+        const start = performance.now();
+        try {
+            const result = await this.getProviderOrganizationsForUser?.(session);
+            this.resetRequestExceptionCount('getOrganizationsForUser');
+            return { value: result, duration: performance.now() - start };
+        }
+        catch (ex) {
+            this.handleProviderException('getOrganizationsForUser', ex, { scope: scope });
+            return { error: toError(ex), duration: performance.now() - start };
+        }
+    }
+    /**
+     * Result-returning list of the projects a git host exposes beneath its orgs, unified into the
+     * {@link ProviderOrganization} shape. Only Azure DevOps has a project tier between org and repo; other
+     * git hosts have none and leave {@link getProviderProjectsForOrg} undefined, so this returns `undefined`
+     * for them (the ProviderBackend facade then treats them as having no projects). With `org`, scopes to
+     * that org's projects; without, returns projects across every org the user can see.
+     */
+    async getProjectsForOrgResult(org, connectionId) {
+        const scope = getScopedLogger();
+        // `connectionId` targets a specific account (multi-account); omitted reads the primary.
+        const session = await this.resolveReadSession(connectionId, scope);
+        if (session == null)
+            return undefined;
+        if (this.getProviderProjectsForOrg == null) {
+            return undefined;
+        }
+        const start = performance.now();
+        try {
+            const result = await this.getProviderProjectsForOrg(session, org);
+            this.resetRequestExceptionCount('getProjectsForOrg');
+            return { value: result, duration: performance.now() - start };
+        }
+        catch (ex) {
+            this.handleProviderException('getProjectsForOrg', ex, { scope: scope });
+            return { error: toError(ex), duration: performance.now() - start };
+        }
+    }
+    /**
+     * Lists repositories under the given organization (org/workspace/group) one page at a time — follow
+     * `paging.cursor` to page, or drain with the integrations provider paging helper.
+     * `options.project` is only meaningful for Azure DevOps, whose repos are scoped by `org` + `project`;
+     * every other host ignores it. (Azure without a project can't page its cross-project merge, so it
+     * returns all matches in a single page.) `truncated === true` means the defensive page-drain
+     * backstop stopped before the upstream listing was exhausted.
+     */
+    async getRepositoriesForOrg(org, options) {
+        return (await this.getRepositoriesForOrgResult(org, options))?.value;
+    }
+    /**
+     * Result-returning core of {@link getRepositoriesForOrg}. Resolves the session for `connectionId`
+     * (or the primary connection when omitted) and recovers a thrown error into `{ error }` for warnings.
+     */
+    async getRepositoriesForOrgResult(org, options) {
+        const scope = getScopedLogger();
+        // `connectionId` targets a specific account (multi-account); omitted reads the primary.
+        const session = await this.resolveReadSession(options?.connectionId, scope);
+        if (session == null)
+            return undefined;
+        const start = performance.now();
+        try {
+            const result = await this.getProviderRepositoriesForOrg?.(session, org, options);
+            this.resetRequestExceptionCount('getRepositoriesForOrg');
+            return { value: result, duration: performance.now() - start };
+        }
+        catch (ex) {
+            this.handleProviderException('getRepositoriesForOrg', ex, { scope: scope });
+            return { error: toError(ex), duration: performance.now() - start };
+        }
+    }
+    /**
+     * Result-returning account-wide, user-affiliated repository read (the org-less
+     * `gk provider repos <provider>` equivalent): repositories the user owns, collaborates on, or can
+     * access through org membership — NOT every repo of every org. Optional: providers without a native
+     * user-affiliated listing (Bitbucket workspaces, Azure orgs, which require an org/workspace scope)
+     * leave the hook undefined and the facade reports the read as unsupported so callers fan out per org.
+     */
+    async getRepositoriesForUserResult(options) {
+        const scope = getScopedLogger();
+        // `connectionId` targets a specific account (multi-account); omitted reads the primary.
+        const session = await this.resolveReadSession(options?.connectionId, scope);
+        if (session == null)
+            return undefined;
+        if (this.getProviderRepositoriesForUser == null) {
+            return undefined;
+        }
+        const start = performance.now();
+        try {
+            const result = await this.getProviderRepositoriesForUser(session, options);
+            this.resetRequestExceptionCount('getRepositoriesForUser');
+            return { value: result, duration: performance.now() - start };
+        }
+        catch (ex) {
+            this.handleProviderException('getRepositoriesForUser', ex, { scope: scope });
+            return { error: toError(ex), duration: performance.now() - start };
+        }
+    }
     async mergePullRequest(pr, options) {
         const scope = getScopedLogger();
         const connected = this.maybeConnected ?? (await this.isConnected());
@@ -147,23 +375,79 @@ export class GitHostIntegration extends IntegrationBase {
         }), options);
         return pr;
     }
-    async getMyIssuesForRepos(reposOrRepoIds, options) {
+    /**
+     * Memoized identity lookups backing filter resolution. Keyed by the session's token fingerprint plus the
+     * scope of the lookup (base URL, and the Azure organization for the per-instance variant), so a different
+     * account, host, or org never reuses an entry and a rotated token simply misses.
+     *
+     * Not cleared when the token changes: one integration instance serves every connection of its provider
+     * (multi-account), so clearing on a fingerprint change would make two accounts reading in alternation
+     * evict each other and defeat the memo. Entries are bounded by tokens x hosts x orgs seen — a handful for
+     * the life of the integration.
+     */
+    _filterAccounts = new Map();
+    /**
+     * Resolves the account a repo-scoped read turns `IssueFilter`/`PullRequestFilter` into a provider
+     * login/id with, memoized per token+scope.
+     *
+     * Every FILTERED read needs this, and `ProvidersApi.getCurrentUser` is a bare round trip — unlike
+     * {@link IntegrationBase.getCurrentAccount}, which the host caches. So a consumer that fans ONE page out
+     * into several filtered reads paid one identity request PER read, all resolving the same account: a
+     * per-user-facet fan-out (author + assignee + review-requested) doubled its request count, and paid it
+     * again on every page turn.
+     *
+     * The promise is memoized rather than the value, so concurrent facets share one in-flight request instead
+     * of racing. A rejection is evicted so the next read retries rather than caching a failure — matching how
+     * `getCurrentAccount` invalidates on error.
+     */
+    getFilterAccount(api, session, customUrl, organization) {
+        const key = `${this.getSessionFingerprint(session)}:${customUrl ?? ''}:${organization ?? ''}`;
+        let pending = this._filterAccounts.get(key);
+        if (pending == null) {
+            const tokenWithInfo = toTokenWithInfo(this.authProvider.id, session);
+            pending = (organization != null
+                ? api.getCurrentUserForInstance(tokenWithInfo, organization, { baseUrl: customUrl })
+                : api.getCurrentUser(tokenWithInfo, { baseUrl: customUrl })).catch((ex) => {
+                this._filterAccounts.delete(key);
+                throw ex;
+            });
+            this._filterAccounts.set(key, pending);
+        }
+        return pending;
+    }
+    async getMyIssuesForRepos(reposOrRepoIds, options, connectionId) {
+        return (await this.getMyIssuesForReposResult(reposOrRepoIds, options, connectionId))?.value;
+    }
+    /**
+     * Result-returning core of {@link getMyIssuesForRepos}. Resolves the session for `connectionId`
+     * (or the primary connection when omitted, so multi-account reads use the right token) and recovers
+     * thrown errors and validation failures into `{ error }` so callers can surface them as warnings
+     * rather than swallowing them to `undefined`.
+     */
+    async getMyIssuesForReposResult(reposOrRepoIds, options, connectionId) {
         const scope = getScopedLogger();
         const providerId = this.authProvider.id;
-        const connected = this.maybeConnected ?? (await this.isConnected());
-        if (!connected)
+        const states = toProviderIssueStates(options?.state);
+        // `connectionId` targets a specific account (multi-account); omitted reads the primary. The session
+        // is resolved here for connectivity/bail; the connection's token is applied per API call below.
+        const session = await this.resolveReadSession(connectionId, scope);
+        if (session == null)
             return undefined;
-        await this.refreshSessionIfExpired(scope);
+        const start = performance.now();
+        const customUrl = options?.customUrl ?? getSelfManagedApiBaseUrl(providerId, session.domain || this.domain, session.protocol);
         const api = await this.getProvidersApi();
         if (providerId !== GitCloudHostIntegrationId.GitLab &&
             (api.isRepoIdsInput(reposOrRepoIds) ||
-                (providerId === GitCloudHostIntegrationId.AzureDevOps &&
+                (isAzureDevOpsProvider(providerId) &&
                     !reposOrRepoIds.every(repo => repo.project != null && repo.namespace != null)))) {
             Logger.warn(`Unsupported input for provider ${providerId}`, 'getIssuesForRepos');
-            return undefined;
+            return {
+                error: new Error(`Unsupported input for provider ${providerId}`),
+                duration: performance.now() - start,
+            };
         }
         let getIssuesOptions;
-        if (providerId === GitCloudHostIntegrationId.AzureDevOps) {
+        if (isAzureDevOpsProvider(providerId)) {
             const organizations = new Set();
             const projects = new Set();
             for (const repo of reposOrRepoIds) {
@@ -172,42 +456,59 @@ export class GitHostIntegration extends IntegrationBase {
             }
             if (organizations.size > 1) {
                 Logger.warn(`Multiple organizations not supported for provider ${providerId}`, 'getIssuesForRepos');
-                return undefined;
+                return {
+                    error: new Error(`Multiple organizations not supported for provider ${providerId}`),
+                    duration: performance.now() - start,
+                };
             }
             else if (organizations.size === 0) {
                 Logger.warn(`No organizations found for provider ${providerId}`, 'getIssuesForRepos');
-                return undefined;
+                return {
+                    error: new Error(`No organizations found for provider ${providerId}`),
+                    duration: performance.now() - start,
+                };
             }
             const organization = first(organizations.values());
             if (options?.filters != null) {
                 if (!api.providerSupportsIssueFilters(providerId, options.filters)) {
                     Logger.warn(`Unsupported filters for provider ${providerId}`, 'getIssuesForRepos');
-                    return undefined;
+                    return {
+                        error: new Error(`Unsupported filters for provider ${providerId}`),
+                        duration: performance.now() - start,
+                    };
                 }
                 let userAccount;
                 try {
-                    userAccount = await api.getCurrentUserForInstance({ providerId: providerId }, organization);
+                    userAccount = await this.getFilterAccount(api, session, customUrl, organization);
                 }
                 catch (ex) {
                     Logger.error(ex, 'getIssuesForRepos');
-                    return undefined;
+                    return { error: toError(ex), duration: performance.now() - start };
                 }
                 if (userAccount == null) {
                     Logger.warn(`Unable to get current user for ${providerId}`, 'getIssuesForRepos');
-                    return undefined;
+                    return {
+                        error: new Error(`Unable to get current user for ${providerId}`),
+                        duration: performance.now() - start,
+                    };
                 }
                 const userFilterProperty = userAccount.name;
                 if (userFilterProperty == null) {
                     Logger.warn(`Unable to get user property for filter for ${providerId}`, 'getIssuesForRepos');
-                    return undefined;
+                    return {
+                        error: new Error(`Unable to get user property for filter for ${providerId}`),
+                        duration: performance.now() - start,
+                    };
                 }
                 getIssuesOptions = {
                     authorLogin: options.filters.includes(IssueFilter.Author) ? userFilterProperty : undefined,
-                    assigneeLogins: options.filters.includes(IssueFilter.Assignee) ? [userFilterProperty] : undefined,
+                    assigneeLogins: !options.includeAllAssignees && options.filters.includes(IssueFilter.Assignee)
+                        ? [userFilterProperty]
+                        : undefined,
                     mentionLogin: options.filters.includes(IssueFilter.Mention) ? userFilterProperty : undefined,
                 };
             }
-            const cursorInfo = JSON.parse(options?.cursor ?? '{}');
+            const cursorInfo = this.parseCursorInfo(options?.cursor);
             const cursors = cursorInfo.cursors ?? [];
             let projectInputs = Array.from(projects.values(), project => ({
                 namespace: organization,
@@ -220,12 +521,43 @@ export class GitHostIntegration extends IntegrationBase {
             try {
                 const cursor = { cursors: [] };
                 let hasMore = false;
+                let truncated = false;
+                let metadata;
                 const data = [];
-                await Promise.all(projectInputs.map(async (projectInput) => {
-                    const results = await api.getIssuesForAzureProject({ providerId: providerId }, projectInput.namespace, projectInput.project, {
+                // `allSettled`, not `Promise.all`: one project's read rejecting must not discard every sibling
+                // project's already-fetched issues and cursors. A rejected project is recorded as a structured
+                // failure so the facade can warn and set `fetchFailed` instead of reporting a partial project set
+                // as complete.
+                const settled = await Promise.allSettled(projectInputs.map(async (projectInput) => {
+                    const results = await api.getIssuesForAzureProject(toTokenWithInfo(providerId, session), projectInput.namespace, projectInput.project, {
                         ...getIssuesOptions,
                         cursor: projectInput.cursor,
+                        baseUrl: customUrl,
+                        // Continuation is driven by the per-project cursor; only apply an explicit page on the
+                        // first request so it can't clobber a continuation cursor on later pages.
+                        page: projectInput.cursor == null ? options?.page : undefined,
+                        pageSize: options?.pageSize,
+                        states: states,
                     });
+                    return { projectInput: projectInput, results: results };
+                }));
+                for (let i = 0; i < settled.length; i++) {
+                    const outcome = settled[i];
+                    const projectInput = projectInputs[i];
+                    if (outcome.status !== 'fulfilled') {
+                        truncated = true;
+                        const failure = toCollectionScopeFailure({
+                            providerId: providerId,
+                            resourceId: projectInput.namespace,
+                            projectId: projectInput.project,
+                        }, outcome.reason);
+                        metadata = mergeCollectionMetadata(metadata, {
+                            completeness: 'partial',
+                            failures: [failure],
+                        });
+                        continue;
+                    }
+                    const { projectInput: _projectInput, results } = outcome.value;
                     data.push(...results.values);
                     if (results.paging?.more) {
                         hasMore = true;
@@ -235,46 +567,78 @@ export class GitHostIntegration extends IntegrationBase {
                             cursor: results.paging.cursor,
                         });
                     }
-                }));
+                }
+                // Keep the requested page number in the composite cursor so the facade can report the real
+                // currentPage when the consumer continues using only the cursor.
+                if (options?.page != null) {
+                    cursor.page = options.page;
+                }
                 return {
-                    values: data,
-                    paging: {
-                        more: hasMore,
-                        cursor: JSON.stringify(cursor),
+                    value: {
+                        values: data,
+                        paging: {
+                            more: hasMore,
+                            cursor: JSON.stringify(cursor),
+                            truncated: truncated || undefined,
+                            // Echo the requested numbered page so the facade reports the real currentPage for
+                            // numbered-page hosts (GitLab/Bitbucket/Azure), not a synthesized 1. Cursor-only hosts
+                            // leave `page` undefined via their own reads.
+                            page: options?.page,
+                        },
+                        metadata: metadata,
                     },
+                    duration: performance.now() - start,
                 };
             }
             catch (ex) {
                 Logger.error(ex, 'getIssuesForRepos');
-                return undefined;
+                return { error: toError(ex), duration: performance.now() - start };
             }
         }
         if (options?.filters != null) {
+            // Validate the requested filters against what this provider actually supports — same guard the Azure
+            // branch above applies. Without it an unsupported filter (e.g. GitLab has no Mention endpoint) would
+            // resolve to no filter property being set and silently degrade to an unfiltered, project-wide read.
+            if (!api.providerSupportsIssueFilters(providerId, options.filters)) {
+                Logger.warn(`Unsupported filters for provider ${providerId}`, 'getIssuesForRepos');
+                return {
+                    error: new Error(`Unsupported filters for provider ${providerId}`),
+                    duration: performance.now() - start,
+                };
+            }
             let userAccount;
             try {
-                userAccount = await api.getCurrentUser({ providerId: providerId });
+                userAccount = await this.getFilterAccount(api, session, customUrl);
             }
             catch (ex) {
                 Logger.error(ex, 'getIssuesForRepos');
-                return undefined;
+                return { error: toError(ex), duration: performance.now() - start };
             }
             if (userAccount == null) {
                 Logger.warn(`Unable to get current user for ${providerId}`, 'getIssuesForRepos');
-                return undefined;
+                return {
+                    error: new Error(`Unable to get current user for ${providerId}`),
+                    duration: performance.now() - start,
+                };
             }
             const userFilterProperty = userAccount.username;
             if (userFilterProperty == null) {
                 Logger.warn(`Unable to get user property for filter for ${providerId}`, 'getIssuesForRepos');
-                return undefined;
+                return {
+                    error: new Error(`Unable to get user property for filter for ${providerId}`),
+                    duration: performance.now() - start,
+                };
             }
             getIssuesOptions = {
                 authorLogin: options.filters.includes(IssueFilter.Author) ? userFilterProperty : undefined,
-                assigneeLogins: options.filters.includes(IssueFilter.Assignee) ? [userFilterProperty] : undefined,
+                assigneeLogins: !options.includeAllAssignees && options.filters.includes(IssueFilter.Assignee)
+                    ? [userFilterProperty]
+                    : undefined,
                 mentionLogin: options.filters.includes(IssueFilter.Mention) ? userFilterProperty : undefined,
             };
         }
         if (api.getProviderIssuesPagingMode(providerId) === PagingMode.Repo && !api.isRepoIdsInput(reposOrRepoIds)) {
-            const cursorInfo = JSON.parse(options?.cursor ?? '{}');
+            const cursorInfo = this.parseCursorInfo(options?.cursor);
             const cursors = cursorInfo.cursors ?? [];
             let repoInputs = reposOrRepoIds.map(repo => ({ repo: repo, cursor: undefined }));
             if (cursors.length > 0) {
@@ -283,105 +647,201 @@ export class GitHostIntegration extends IntegrationBase {
             try {
                 const cursor = { cursors: [] };
                 let hasMore = false;
+                let truncated = false;
+                let metadata;
                 const data = [];
-                await Promise.all(repoInputs.map(async (repoInput) => {
-                    const results = await api.getIssuesForRepo({ providerId: providerId }, repoInput.repo, {
+                // `allSettled`, not `Promise.all`: one repo's read rejecting must not discard every sibling repo's
+                // already-fetched issues and cursors. A rejected repo is recorded as a structured failure so the
+                // facade can warn and set `fetchFailed` instead of reporting a partial repo set as complete.
+                const settled = await Promise.allSettled(repoInputs.map(async (repoInput) => {
+                    const results = await api.getIssuesForRepo(toTokenWithInfo(providerId, session), repoInput.repo, {
                         ...getIssuesOptions,
                         cursor: repoInput.cursor,
-                        baseUrl: options?.customUrl,
+                        baseUrl: customUrl,
+                        // Continuation is driven by the per-repo cursor; only apply an explicit page on the
+                        // first request so it can't clobber a continuation cursor on later pages.
+                        page: repoInput.cursor == null ? options?.page : undefined,
+                        pageSize: options?.pageSize,
+                        states: states,
                     });
+                    return { repoInput: repoInput, results: results };
+                }));
+                for (let i = 0; i < settled.length; i++) {
+                    const outcome = settled[i];
+                    const repoInput = repoInputs[i];
+                    if (outcome.status !== 'fulfilled') {
+                        truncated = true;
+                        const failure = toCollectionScopeFailure({
+                            providerId: providerId,
+                            repositoryId: `${repoInput.repo.namespace}/${repoInput.repo.name}`,
+                        }, outcome.reason);
+                        metadata = mergeCollectionMetadata(metadata, {
+                            completeness: 'partial',
+                            failures: [failure],
+                        });
+                        continue;
+                    }
+                    const { repoInput: _repoInput, results } = outcome.value;
                     data.push(...results.values);
                     if (results.paging?.more) {
                         hasMore = true;
                         cursor.cursors.push({ repo: repoInput.repo, cursor: results.paging.cursor });
                     }
-                }));
+                }
+                if (options?.page != null) {
+                    cursor.page = options.page;
+                }
                 return {
-                    values: data,
-                    paging: {
-                        more: hasMore,
-                        cursor: JSON.stringify(cursor),
+                    value: {
+                        values: data,
+                        paging: {
+                            more: hasMore,
+                            cursor: JSON.stringify(cursor),
+                            truncated: truncated || undefined,
+                            // Echo the requested numbered page so the facade reports the real currentPage for
+                            // numbered-page hosts (GitLab/Bitbucket/Azure), not a synthesized 1. Cursor-only hosts
+                            // leave `page` undefined via their own reads.
+                            page: options?.page,
+                        },
+                        metadata: metadata,
                     },
+                    duration: performance.now() - start,
                 };
             }
             catch (ex) {
                 Logger.error(ex, 'getIssuesForRepos');
-                return undefined;
+                return { error: toError(ex), duration: performance.now() - start };
             }
         }
         try {
-            return await api.getIssuesForRepos({ providerId: providerId }, reposOrRepoIds, {
+            const result = await api.getIssuesForRepos(toTokenWithInfo(providerId, session), reposOrRepoIds, {
                 ...getIssuesOptions,
                 cursor: options?.cursor,
-                baseUrl: options?.customUrl,
+                baseUrl: customUrl,
+                page: options?.page,
+                pageSize: options?.pageSize,
+                states: states,
             });
+            return { value: result, duration: performance.now() - start };
         }
         catch (ex) {
             Logger.error(ex, 'getIssuesForRepos');
-            return undefined;
+            return { error: toError(ex), duration: performance.now() - start };
         }
     }
-    async getMyPullRequestsForRepos(reposOrRepoIds, options) {
+    /**
+     * Repo-scoped "my issues" read returning the normalized {@link IssueShape} the ProviderBackend facade
+     * consumes (`listIssuesPage({ repos })`, `broadenIssues`). Maps {@link getMyIssuesForReposResult} — the raw
+     * provider-apis path — to IssueShape.
+     *
+     * It's the seam rather than an inline map so a provider whose only issue client already yields normalized
+     * shapes, and isn't wired into the raw path, can override it and serve these reads without a
+     * `ProviderIssue` round-trip. No provider does today: the one candidate (Bitbucket Cloud's legacy
+     * `getUsersIssuesForRepo`) reports `supportsIssues: false`, so the facade never reaches this for it.
+     */
+    async getMyIssuesForReposAsShapesResult(reposOrRepoIds, options, connectionId) {
+        const result = await this.getMyIssuesForReposResult(reposOrRepoIds, options, connectionId);
+        if (result == null)
+            return undefined;
+        if (result.error != null)
+            return { error: result.error, duration: result.duration };
+        if (result.value == null)
+            return { value: undefined, duration: result.duration };
+        const values = result.value.values
+            .map(issue => toIssueShape(issue, this))
+            .filter((issue) => issue != null);
+        return { value: { ...result.value, values: values }, duration: result.duration };
+    }
+    async getMyPullRequestsForRepos(reposOrRepoIds, options, connectionId) {
+        return (await this.getMyPullRequestsForReposResult(reposOrRepoIds, options, connectionId))?.value;
+    }
+    /**
+     * Result-returning core of {@link getMyPullRequestsForRepos}. Resolves the session for `connectionId`
+     * (or the primary connection when omitted, so multi-account reads use the right token) and recovers
+     * thrown errors and validation failures into `{ error }` so callers can surface them as warnings
+     * rather than swallowing them to `undefined`.
+     */
+    async getMyPullRequestsForReposResult(reposOrRepoIds, options, connectionId) {
         const scope = getScopedLogger();
         const providerId = this.authProvider.id;
-        const connected = this.maybeConnected ?? (await this.isConnected());
-        if (!connected)
+        const states = toProviderPullRequestStates(options?.state);
+        // `connectionId` targets a specific account (multi-account); omitted reads the primary. The session
+        // is resolved here for connectivity/bail; the connection's token is applied per API call below.
+        const session = await this.resolveReadSession(connectionId, scope);
+        if (session == null)
             return undefined;
-        await this.refreshSessionIfExpired(scope);
+        const start = performance.now();
+        const customUrl = options?.customUrl ?? getSelfManagedApiBaseUrl(providerId, session.domain || this.domain, session.protocol);
         const api = await this.getProvidersApi();
         if (providerId !== GitCloudHostIntegrationId.GitLab &&
             (api.isRepoIdsInput(reposOrRepoIds) ||
-                (providerId === GitCloudHostIntegrationId.AzureDevOps &&
+                (isAzureDevOpsProvider(providerId) &&
                     !reposOrRepoIds.every(repo => repo.project != null && repo.namespace != null)))) {
             Logger.warn(`Unsupported input for provider ${providerId}`);
-            return undefined;
+            return {
+                error: new Error(`Unsupported input for provider ${providerId}`),
+                duration: performance.now() - start,
+            };
         }
         let getPullRequestsOptions;
         if (options?.filters != null) {
             if (!api.providerSupportsPullRequestFilters(providerId, options.filters)) {
                 Logger.warn(`Unsupported filters for provider ${providerId}`, 'getPullRequestsForRepos');
-                return undefined;
+                return {
+                    error: new Error(`Unsupported filters for provider ${providerId}`),
+                    duration: performance.now() - start,
+                };
             }
             let userAccount;
-            if (providerId === GitCloudHostIntegrationId.AzureDevOps) {
+            if (isAzureDevOpsProvider(providerId)) {
                 const organizations = new Set();
                 for (const repo of reposOrRepoIds) {
                     organizations.add(repo.namespace);
                 }
                 if (organizations.size > 1) {
                     Logger.warn(`Multiple organizations not supported for provider ${providerId}`, 'getPullRequestsForRepos');
-                    return undefined;
+                    return {
+                        error: new Error(`Multiple organizations not supported for provider ${providerId}`),
+                        duration: performance.now() - start,
+                    };
                 }
                 else if (organizations.size === 0) {
                     Logger.warn(`No organizations found for provider ${providerId}`, 'getPullRequestsForRepos');
-                    return undefined;
+                    return {
+                        error: new Error(`No organizations found for provider ${providerId}`),
+                        duration: performance.now() - start,
+                    };
                 }
                 const organization = first(organizations.values());
                 try {
-                    userAccount = await api.getCurrentUserForInstance({ providerId: providerId }, organization);
+                    userAccount = await this.getFilterAccount(api, session, customUrl, organization);
                 }
                 catch (ex) {
                     Logger.error(ex, 'getPullRequestsForRepos');
-                    return undefined;
+                    return { error: toError(ex), duration: performance.now() - start };
                 }
             }
             else {
                 try {
-                    userAccount = await api.getCurrentUser({ providerId: providerId });
+                    userAccount = await this.getFilterAccount(api, session, customUrl);
                 }
                 catch (ex) {
                     Logger.error(ex, 'getPullRequestsForRepos');
-                    return undefined;
+                    return { error: toError(ex), duration: performance.now() - start };
                 }
             }
             if (userAccount == null) {
                 Logger.warn(`Unable to get current user for ${providerId}`, 'getPullRequestsForRepos');
-                return undefined;
+                return {
+                    error: new Error(`Unable to get current user for ${providerId}`),
+                    duration: performance.now() - start,
+                };
             }
             let userFilterProperty;
             switch (providerId) {
                 case GitCloudHostIntegrationId.Bitbucket:
                 case GitCloudHostIntegrationId.AzureDevOps:
+                case GitSelfManagedHostIntegrationId.AzureDevOpsServer:
                     userFilterProperty = userAccount.id;
                     break;
                 default:
@@ -390,20 +850,45 @@ export class GitHostIntegration extends IntegrationBase {
             }
             if (userFilterProperty == null) {
                 Logger.warn(`Unable to get user property for filter for ${providerId}`, 'getPullRequestsForRepos');
-                return undefined;
+                return {
+                    error: new Error(`Unable to get user property for filter for ${providerId}`),
+                    duration: performance.now() - start,
+                };
+            }
+            // Route the "review requested from me" filter to the field each provider actually reads:
+            // GitHub/GitLab expect a login (reviewRequestedLogin), Bitbucket/Azure an account id (reviewerId),
+            // and Bitbucket Server a login (reviewerLogin). `userFilterProperty` is already the account id for
+            // Bitbucket/Azure and the username for the rest.
+            let reviewRequestedLogin;
+            let reviewerId;
+            let reviewerLogin;
+            if (options.filters.includes(PullRequestFilter.ReviewRequested)) {
+                switch (providerId) {
+                    case GitCloudHostIntegrationId.Bitbucket:
+                    case GitCloudHostIntegrationId.AzureDevOps:
+                    case GitSelfManagedHostIntegrationId.AzureDevOpsServer:
+                        reviewerId = userFilterProperty;
+                        break;
+                    case GitSelfManagedHostIntegrationId.BitbucketServer:
+                        reviewerLogin = userFilterProperty;
+                        break;
+                    default:
+                        reviewRequestedLogin = userFilterProperty;
+                        break;
+                }
             }
             getPullRequestsOptions = {
                 authorLogin: options.filters.includes(PullRequestFilter.Author) ? userFilterProperty : undefined,
                 assigneeLogins: options.filters.includes(PullRequestFilter.Assignee) ? [userFilterProperty] : undefined,
-                reviewRequestedLogin: options.filters.includes(PullRequestFilter.ReviewRequested)
-                    ? userFilterProperty
-                    : undefined,
+                reviewRequestedLogin: reviewRequestedLogin,
+                reviewerId: reviewerId,
+                reviewerLogin: reviewerLogin,
                 mentionLogin: options.filters.includes(PullRequestFilter.Mention) ? userFilterProperty : undefined,
             };
         }
         if (api.getProviderPullRequestsPagingMode(providerId) === PagingMode.Repo &&
             !api.isRepoIdsInput(reposOrRepoIds)) {
-            const cursorInfo = JSON.parse(options?.cursor ?? '{}');
+            const cursorInfo = this.parseCursorInfo(options?.cursor);
             const cursors = cursorInfo.cursors ?? [];
             let repoInputs = reposOrRepoIds.map(repo => ({ repo: repo, cursor: undefined }));
             if (cursors.length > 0) {
@@ -412,55 +897,129 @@ export class GitHostIntegration extends IntegrationBase {
             try {
                 const cursor = { cursors: [] };
                 let hasMore = false;
+                let truncated = false;
+                let metadata;
+                const failures = [];
                 const data = [];
-                await Promise.all(repoInputs.map(async (repoInput) => {
-                    const results = await api.getPullRequestsForRepo({ providerId: providerId }, repoInput.repo, {
+                // `allSettled`, not `Promise.all`: one repo's read rejecting must not discard every sibling repo's
+                // already-fetched PRs and cursors. A rejected repo becomes a structured `CollectionScopeFailure`
+                // (attributed to that repo) so the facade warns on it + sets `fetchFailed`, while the survivors and
+                // their continuation cursors are still returned.
+                const settled = await Promise.allSettled(repoInputs.map(async (repoInput) => {
+                    const results = await api.getPullRequestsForRepo(toTokenWithInfo(providerId, session), repoInput.repo, {
                         ...getPullRequestsOptions,
                         cursor: repoInput.cursor,
-                        baseUrl: options?.customUrl,
+                        baseUrl: customUrl,
+                        // Continuation is driven by the per-repo cursor; only apply an explicit page on the
+                        // first request so it can't clobber a continuation cursor on later pages.
+                        page: repoInput.cursor == null ? options?.page : undefined,
+                        pageSize: options?.pageSize,
+                        states: states,
+                        // Azure DevOps only populates clone URLs on request (extra call); no-op elsewhere.
+                        includeRemoteInfo: isAzureDevOpsProvider(providerId) ? true : undefined,
                     });
+                    return { repoInput: repoInput, results: results };
+                }));
+                // `allSettled` preserves order, so `settled[i]` is `repoInputs[i]`.
+                settled.forEach((outcome, i) => {
+                    if (outcome.status !== 'fulfilled') {
+                        const failedRepo = repoInputs[i].repo;
+                        failures.push(toCollectionScopeFailure({ providerId: providerId, repositoryId: `${failedRepo.namespace}/${failedRepo.name}` }, outcome.reason));
+                        return;
+                    }
+                    const { repoInput, results } = outcome.value;
                     data.push(...results.values);
+                    // Fan-out across repos: preserve each repo's SDK completeness/failures and its terminal
+                    // truncation so a single failed/incomplete repo isn't lost when merged with its siblings.
+                    metadata = mergeCollectionMetadata(metadata, results.metadata);
+                    if (results.paging?.truncated) {
+                        truncated = true;
+                    }
                     if (results.paging?.more) {
                         hasMore = true;
                         cursor.cursors.push({ repo: repoInput.repo, cursor: results.paging.cursor });
                     }
-                }));
+                });
+                // Merge the GitLens-side per-repo rejections into the SDK metadata so both flow through the same
+                // warning/fetchFailed assessment downstream.
+                if (failures.length > 0) {
+                    metadata = mergeCollectionMetadata(metadata, { completeness: 'partial', failures: failures });
+                }
+                // Keep the requested page number in the composite cursor so the facade can report the real
+                // currentPage when the consumer continues using only the cursor.
+                if (options?.page != null) {
+                    cursor.page = options.page;
+                }
                 return {
-                    values: data,
-                    paging: {
-                        more: hasMore,
-                        cursor: JSON.stringify(cursor),
+                    value: {
+                        values: data,
+                        paging: {
+                            more: hasMore,
+                            cursor: JSON.stringify(cursor),
+                            truncated: truncated || undefined,
+                            // Echo the requested numbered page so the facade reports the real currentPage for
+                            // numbered-page hosts (GitLab/Bitbucket/Azure), not a synthesized 1. Cursor-only hosts
+                            // leave `page` undefined via their own reads.
+                            page: options?.page,
+                        },
+                        metadata: metadata,
                     },
+                    duration: performance.now() - start,
                 };
             }
             catch (ex) {
                 Logger.error(ex, 'getPullRequestsForRepos');
-                return undefined;
+                return { error: toError(ex), duration: performance.now() - start };
             }
         }
         try {
-            return await api.getPullRequestsForRepos({ providerId: providerId }, reposOrRepoIds, {
+            const result = await api.getPullRequestsForRepos(toTokenWithInfo(providerId, session), reposOrRepoIds, {
                 ...getPullRequestsOptions,
                 cursor: options?.cursor,
-                baseUrl: options?.customUrl,
+                baseUrl: customUrl,
+                page: options?.page,
+                pageSize: options?.pageSize,
+                states: states,
+                // Azure DevOps only populates clone URLs on request (extra call); no-op elsewhere.
+                includeRemoteInfo: isAzureDevOpsProvider(providerId) ? true : undefined,
             });
+            return { value: result, duration: performance.now() - start };
         }
         catch (ex) {
             Logger.error(ex, 'getPullRequestsForRepos');
-            return undefined;
+            return { error: toError(ex), duration: performance.now() - start };
         }
     }
-    async searchMyPullRequests(repos, cancellation, silent) {
+    async searchMyPullRequests(repos, cancellation, silent, connectionId, state, options) {
         const scope = getScopedLogger();
-        const connected = this.maybeConnected ?? (await this.isConnected());
-        if (!connected)
+        // `connectionId` targets a specific account (multi-account); omitted reads the primary.
+        const session = await this.resolveReadSession(connectionId, scope);
+        if (session == null)
             return undefined;
-        await this.refreshSessionIfExpired(scope);
         const start = performance.now();
         try {
-            const pullRequests = await this.searchProviderMyPullRequests(this._session, repos != null ? (Array.isArray(repos) ? repos : [repos]) : undefined, cancellation, silent);
+            // Prefer the optional metadata-aware path for account-wide reads so partial failures (e.g. one Azure
+            // org rejecting) are surfaced as a soft `{ value, error }` instead of being lost. Repo-scoped reads and
+            // providers without that override keep using the legacy array path.
+            let result;
+            if (this.searchProviderMyPullRequestsResult != null && repos == null) {
+                result = await this.searchProviderMyPullRequestsResult(session, repos != null ? (Array.isArray(repos) ? repos : [repos]) : undefined, cancellation, silent, state, options);
+            }
+            else {
+                result = {
+                    value: await this.searchProviderMyPullRequests(session, repos != null ? (Array.isArray(repos) ? repos : [repos]) : undefined, cancellation, silent, state, options),
+                };
+            }
             this.resetRequestExceptionCount('searchMyPullRequests');
-            return { value: pullRequests, duration: performance.now() - start };
+            // `IntegrationResult` is a strict union of value-only or error-only (and may be `undefined`). Return the
+            // matching branch explicitly; a missing result is treated as a successful empty read.
+            if (result == null) {
+                return { value: undefined, duration: performance.now() - start };
+            }
+            if (result.error != null) {
+                return { error: result.error, duration: performance.now() - start };
+            }
+            return { value: result.value, duration: performance.now() - start };
         }
         catch (ex) {
             this.handleProviderException('searchMyPullRequests', ex, {
@@ -468,19 +1027,68 @@ export class GitHostIntegration extends IntegrationBase {
                 silent: true,
             });
             return {
-                error: ex,
+                error: toError(ex),
                 duration: performance.now() - start,
             };
         }
     }
-    async searchPullRequests(searchQuery, repos, cancellation) {
+    /**
+     * Account-wide, user-scoped counterpart of {@link getMyPullRequestsForReposResult} that returns the raw
+     * `ProviderPullRequest` shape (not the normalized model). Unlike the repo-scoped core, this needs no
+     * `repos` — it reads the current user's pull requests across the account, so the ProviderBackend sweep
+     * can drive its Kanban "done" column even when no repositories are supplied (where the repo-scoped core
+     * rejects an empty `repos` input). Recovers thrown errors into `{ error }` so callers surface warnings.
+     */
+    async getMyPullRequestsForUserResult(options, connectionId) {
         const scope = getScopedLogger();
-        const connected = this.maybeConnected ?? (await this.isConnected());
-        if (!connected)
+        // `connectionId` targets a specific account (multi-account); omitted reads the primary.
+        const session = await this.resolveReadSession(connectionId, scope);
+        if (session == null)
             return undefined;
-        await this.refreshSessionIfExpired(scope);
+        if (this.getProviderMyPullRequestsForUser == null) {
+            return undefined;
+        }
+        const start = performance.now();
         try {
-            const prs = await this.searchProviderPullRequests?.(this._session, searchQuery, repos != null ? (Array.isArray(repos) ? repos : [repos]) : undefined, cancellation);
+            const result = await this.getProviderMyPullRequestsForUser(session, options);
+            this.resetRequestExceptionCount('getMyPullRequestsForUser');
+            return { value: result, duration: performance.now() - start };
+        }
+        catch (ex) {
+            this.handleProviderException('getMyPullRequestsForUser', ex, { scope: scope });
+            return { error: toError(ex), duration: performance.now() - start };
+        }
+    }
+    /**
+     * Parses a Repo/Project paging cursor into its `cursors` bundle. Guards against valid JSON whose
+     * `cursors` is a truthy non-array (e.g. `{ "cursors": "..." }`), which would otherwise bypass the
+     * `?? []` fallback at call sites and flow into `.map()` downstream, throwing instead of degrading to
+     * the first page.
+     */
+    parseCursorInfo(cursor) {
+        try {
+            const parsed = JSON.parse(cursor ?? '{}');
+            return Array.isArray(parsed?.cursors) ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async searchPullRequests(searchQuery, repos, cancellation, connectionIdOrOptions, options) {
+        // `connectionId` (string) can be omitted when passing `options`; split the overlapping 4th arg.
+        // When the 4th arg isn't the options object (a string `connectionId` or `undefined`), fall back to
+        // the 5th-arg `options` so an explicit `undefined` connectionId still honors state filtering.
+        const connectionId = typeof connectionIdOrOptions === 'string' ? connectionIdOrOptions : undefined;
+        const searchOptions = connectionIdOrOptions != null && typeof connectionIdOrOptions !== 'string'
+            ? connectionIdOrOptions
+            : options;
+        const scope = getScopedLogger();
+        // `connectionId` targets a specific account (multi-account); omitted reads the primary.
+        const session = await this.resolveReadSession(connectionId, scope);
+        if (session == null)
+            return undefined;
+        try {
+            const prs = await this.searchProviderPullRequests?.(session, searchQuery, repos != null ? (Array.isArray(repos) ? repos : [repos]) : undefined, cancellation, searchOptions);
             this.resetRequestExceptionCount('searchPullRequests');
             return prs;
         }
@@ -497,6 +1105,10 @@ __decorate([
     gate(),
     trace()
 ], GitHostIntegration.prototype, "getAccountForEmail", null);
+__decorate([
+    gate(),
+    trace()
+], GitHostIntegration.prototype, "getSshSigningKeysForEmails", null);
 __decorate([
     gate(),
     trace()
@@ -507,6 +1119,18 @@ __decorate([
 __decorate([
     trace()
 ], GitHostIntegration.prototype, "getRepositoryMetadata", null);
+__decorate([
+    trace()
+], GitHostIntegration.prototype, "getOrganizationsForUserResult", null);
+__decorate([
+    trace()
+], GitHostIntegration.prototype, "getProjectsForOrgResult", null);
+__decorate([
+    trace()
+], GitHostIntegration.prototype, "getRepositoriesForOrgResult", null);
+__decorate([
+    trace()
+], GitHostIntegration.prototype, "getRepositoriesForUserResult", null);
 __decorate([
     trace()
 ], GitHostIntegration.prototype, "getPullRequestForBranch", null);