@kubohiroya/turbowarp-plus-editor-git 0.16.1 → 0.18.0

package/src/pull-request-panel.tsx

@@ -1,4 +1,4 @@
-import React, {useEffect, useMemo, useState} from 'react';
+import React, {useEffect, useMemo, useRef, useState} from 'react';
 import {createGitHubPullRequests, gitHubRepositoryFromOrigin, PullRequestError} from './github-pull-requests.js';
 import type {GitHubPullRequests} from './github-pull-requests.js';
 import {ProjectSourceReview} from './project-source-review.js';
@@ -7,6 +7,10 @@ import type {Repository} from './repository.js';
 import type {ProjectBlockLocator} from './block-diff-location.js';
 import {readProjectSourceDiff} from './project-source-patch.js';
 import type {ProjectSourceTabsFile} from './project-source-tabs.js';
+import {GitPanelError} from './filesystem.js';
+import type {GetRemoteSession} from './remote-operations.js';
+import type {ProjectSourceReviewFile} from './project-source-review.js';
+import {pullRequestBranch} from './local-operations.js';
 
 type OpenTabs = (key: string, files: readonly ProjectSourceTabsFile[], rememberAs?: string) => number;
 
@@ -20,7 +24,19 @@ const en = {
     rateLimit: 'The public GitHub API rate limit was reached. Try again after the limit resets.',
     failed: 'Could not read GitHub. Try again.', changed: 'The pull request changed while it was being read. Open it again.',
     tooManyFiles: 'GitHub only returns the first 3,000 changed files. This pull request exceeds that limit.',
-    openTabs: 'Open as tabs'
+    openTabs: 'Open as tabs',
+    session: 'Connect to GitHub again (GitHub connection) to read this pull request.',
+    forbidden: 'The GitHub connection is not allowed to read this repository.',
+    pullRequestNotFound: 'This repository has no pull request with this number.',
+    network: 'Could not reach GitHub through the connection. Check the network and try again.',
+    remoteFailed: 'Could not read the pull request through the GitHub connection. Try again.',
+    baseMissing: 'The base branch is not on GitHub. Choose another base branch.',
+    viaConnection: 'Read through the GitHub connection.',
+    listPrivate: 'The list uses the public GitHub API. Enter a pull request number to read it through the connection.',
+    noMetadata: 'The title and base branch are not available without the public GitHub API. Choose the base branch to compare with.',
+    base: 'Base branch', pullRequest: 'Pull request',
+    openLocally: 'Open here as {branch}',
+    openLocallyHint: 'Creates the local branch {branch} at this version, switches to it and opens the project, so it can be run. Unsaved edits and unrecorded changes stop it. Switch back in Local changes.'
 };
 const ja: typeof en = {
     title: 'プルリクエスト', number: 'プルリクエスト番号', openNumber: 'PR を開く',
@@ -33,33 +49,76 @@ const ja: typeof en = {
     failed: 'GitHub から取得できませんでした。再試行してください。',
     changed: '取得中にプルリクエストが更新されました。もう一度開いてください。',
     tooManyFiles: '変更ファイルが GitHub API の取得上限である 3,000 件を超えています。',
-    openTabs: 'タブで開く'
+    openTabs: 'タブで開く',
+    session: 'この PR を読むには、GitHub 接続でもう一度接続してください。',
+    forbidden: 'GitHub 接続に、このリポジトリを読む権限がありません。',
+    pullRequestNotFound: 'このリポジトリに、この番号のプルリクエストはありません。',
+    network: 'GitHub 接続で GitHub に届きませんでした。ネットワークを確認して、もう一度試してください。',
+    remoteFailed: 'GitHub 接続でプルリクエストを読めませんでした。もう一度試してください。',
+    baseMissing: 'ベースのブランチが GitHub にありません。別のベースを選んでください。',
+    viaConnection: 'GitHub 接続で取得しました。',
+    listPrivate: '一覧は公開 GitHub API を使います。番号を入れると、GitHub 接続で読みます。',
+    noMetadata: '公開 GitHub API を使えないため、題名とベースのブランチがわかりません。比べるベースのブランチを選んでください。',
+    base: 'ベースのブランチ', pullRequest: 'プルリクエスト',
+    openLocally: '{branch} として手元で開く',
+    openLocallyHint: 'この版にローカルブランチ {branch} を作って切り替え、作品を開き直して実行できるようにします。保存していない編集や記録していない変更があるときは行いません。元に戻すときは「ローカルの変更」で切り替えてください。'
 };
 
+const gitErrors = ['session', 'forbidden', 'pullRequestNotFound', 'network', 'remoteFailed', 'baseMissing', 'changed'] as const;
 function errorMessage(error: unknown, labels: typeof en) {
-    return error instanceof PullRequestError ? labels[error.code] : labels.failed;
+    if (error instanceof PullRequestError) return labels[error.code];
+    if (error instanceof GitPanelError) {
+        const code = gitErrors.find(code => code === error.code);
+        return code ? labels[code] : labels.failed;
+    }
+    return labels.failed;
+}
+
+/**
+ * Opens a pull request version fetched over the connection in the work tree: the host creates (or reuses) the local
+ * branch `pullRequestBranch(number)` at `head` and switches to it. `busy` disables the button.
+ */
+export interface PullRequestOpenLocally {
+    open(number: number, head: string): unknown;
+    busy: boolean;
+}
+
+/** The person's GitHub connection: while it is connected, pull request contents are read over Git Smart HTTP. */
+export interface PullRequestConnection {
+    getSession: GetRemoteSession;
+    connected(): boolean;
 }
 
 type Result<T> = {data: T; error?: never} | {data?: never; error: string};
 type Listing = Awaited<ReturnType<GitHubPullRequests['list']>>;
-type Pull = Awaited<ReturnType<GitHubPullRequests['load']>>;
+type Metadata = Awaited<ReturnType<GitHubPullRequests['metadata']>>;
+/** A pull request to show: from the public API, or from Git objects fetched over the connection. */
+type Pull = {
+    number: number; title: string; description: string; author?: string; state?: Metadata['state'];
+    head: {sha: string; ref: string}; base: {ref: string | null; sha: string};
+    files: readonly ProjectSourceReviewFile[]; url: string;
+    /** Set when the contents came over the connection: the branches to compare with, when the API gave no base. */
+    git?: {branches: readonly string[] | null};
+};
 
-function PullRequests({name, labels, locale, renderBlock, locateFor, openTabs}: {
+function PullRequests({name, labels, locale, renderBlock, locateFor, openTabs, repository, connection, openLocally}: {
     name: string; labels: typeof en; locale: string; renderBlock: ProjectBlockRenderer;
     locateFor?(path: string, headSha: string): ProjectBlockLocator | undefined;
-    openTabs?: OpenTabs;
+    openTabs?: OpenTabs; repository: Repository; connection?: PullRequestConnection; openLocally?: PullRequestOpenLocally;
 }) {
     const client = useMemo(() => createGitHubPullRequests(name), [name]);
     const [page, setPage] = useState(1);
     const [listing, setListing] = useState<{page: number; result: Result<Listing>}>();
     const [input, setInput] = useState('');
-    const [selection, setSelection] = useState<{number: number}>();
+    const [selection, setSelection] = useState<{number: number; base?: string}>();
     const [loaded, setLoaded] = useState<{selection: NonNullable<typeof selection>; result: Result<Pull>}>();
     const list = listing?.page === page ? listing.result : undefined;
+    const [listConnected, setListConnected] = useState(false);
     const detail = loaded?.selection === selection ? loaded?.result : undefined;
     useEffect(() => {
         const controller = new AbortController();
         setListing(undefined);
+        setListConnected(!!connection?.connected());
         void client.list(page, controller.signal).then(data => {
             if (!controller.signal.aborted) setListing({page, result: {data}});
         }, error => {
@@ -70,13 +129,44 @@ function PullRequests({name, labels, locale, renderBlock, locateFor, openTabs}:
     useEffect(() => {
         if (!selection) return;
         const controller = new AbortController();
-        void client.load(selection.number, controller.signal).then(data => {
+        const load = (): Promise<Pull> => connection?.connected() ?
+            loadThroughConnection(selection.number, selection.base, controller.signal) : client.load(selection.number, controller.signal);
+        void load().then(data => {
             if (!controller.signal.aborted) setLoaded({selection, result: {data}});
         }, error => {
             if (!controller.signal.aborted) setLoaded({selection, result: {error: errorMessage(error, labels)}});
         });
         return () => controller.abort();
     }, [client, selection, labels]);
+    const fetched = useRef<{number: number; head: string; branches: readonly string[]; defaultBranch: string | null}>();
+    /**
+     * Fetches `refs/pull/<number>/head` and the branches over Git Smart HTTP and compares them from local objects. The
+     * public API only adds the title, description and base when it can read the repository; the contents never come
+     * from it, so a private repository is read only through the connection.
+     */
+    const loadThroughConnection = async (number: number, chosenBase: string | undefined, signal: AbortSignal): Promise<Pull> => {
+        const guard = () => {if (signal.aborted) throw new GitPanelError('changed');};
+        let head: string, branches: readonly string[], defaultBranch: string | null, metadata: Metadata | null = null;
+        if (chosenBase !== undefined && fetched.current?.number === number) {
+            ({head, branches, defaultBranch} = fetched.current);
+        } else {
+            metadata = await client.metadata(number, signal).catch(error => {
+                if (signal.aborted) throw error;
+                return null;
+            });
+            const result = await repository.fetchPullRequest(number, connection!.getSession, guard, signal);
+            if (metadata && metadata.head.sha !== result.head) throw new PullRequestError('changed');
+            ({head, branches, defaultBranch} = result);
+            fetched.current = {number, head, branches, defaultBranch};
+        }
+        const branch = chosenBase ?? metadata?.base.ref ?? defaultBranch ?? branches[0];
+        const read = await repository.readPullRequest(head, {sha: metadata?.base.sha, branch});
+        guard();
+        return {number, title: metadata?.title ?? `${labels.pullRequest} #${number}`, description: metadata?.description ?? '',
+            author: metadata?.author, state: metadata?.state, head: {sha: head, ref: metadata?.head.ref ?? `pull/${number}/head`},
+            base: read.base, files: read.files, url: 'https://github.com/' + name + '/pull/' + number,
+            git: {branches: metadata ? null : branches}};
+    };
     const choose = (number: number) => {
         if (!Number.isSafeInteger(number) || number < 1) return;
         setSelection({number});
@@ -93,7 +183,8 @@ function PullRequests({name, labels, locale, renderBlock, locateFor, openTabs}:
                 <button type="submit">{labels.openNumber}</button>
             </form>
             {!list && <p role="status">{labels.loading}</p>}
-            {list?.error && <p role="alert">{list.error}</p>}
+            {list?.error && (listConnected && list.error === labels.unavailable ?
+                <p role="status">{labels.listPrivate}</p> : <p role="alert">{list.error}</p>)}
             {list?.data && <>
                 {!list.data.items.length && <p>{labels.empty}</p>}
                 <ul>{list.data.items.map(item => <li key={item.number}>
@@ -112,9 +203,13 @@ function PullRequests({name, labels, locale, renderBlock, locateFor, openTabs}:
             {detail?.error && <p role="alert">{detail.error}</p>}
             {pr && <>
                 <p className="twgit-pr-revision">
-                    <strong>#{pr.number} · {labels[pr.state]}</strong>
+                    <strong>#{pr.number}{pr.state && <> · {labels[pr.state]}</>}</strong>
                     {pr.author && <span>{pr.author}</span>}
-                    <code title={pr.head.sha}>{pr.head.ref} → {pr.base.ref}</code>
+                    <code title={pr.head.sha}>{pr.head.ref} → {pr.base.ref ?? pr.base.sha.slice(0, 12)}</code>
+                    {pr.git?.branches && <label>{labels.base} <select data-git-pr-base="" value={pr.base.ref ?? ''}
+                        onChange={event => setSelection({number: pr.number, base: event.currentTarget.value})}>
+                        {pr.git.branches.map(branch => <option key={branch} value={branch}>{branch}</option>)}
+                    </select></label>}
                     <a href={pr.url} target="_blank" rel="noreferrer">{labels.onGitHub}</a>
                     {openTabs && <button type="button" data-git-open-tabs="" onClick={() => openTabs(`${name}#${pr.number}@${pr.head.sha}`,
                         pr.files.flatMap(file => {
@@ -128,7 +223,12 @@ function PullRequests({name, labels, locale, renderBlock, locateFor, openTabs}:
                             return projects ? [{path: file.path, before: projects[0], after: projects[1], loadAsset: file.loadAsset,
                                 locateBlock: locateFor?.(file.path, pr.head.sha)}] : [];
                         }), `${name}#${pr.number}`)}>{labels.openTabs}</button>}
+                    {pr.git && openLocally && <button type="button" data-git-open-pr-locally="" disabled={openLocally.busy}
+                        title={labels.openLocallyHint.replace('{branch}', pullRequestBranch(pr.number))}
+                        onClick={() => void openLocally.open(pr.number, pr.head.sha)}>
+                        {labels.openLocally.replace('{branch}', pullRequestBranch(pr.number))}</button>}
                 </p>
+                {pr.git && <p className="twgit-context" role="status">{labels.viaConnection}{pr.git.branches && <> {labels.noMetadata}</>}</p>}
                 <ProjectSourceReview title={pr.title} description={pr.description} files={locateFor ? pr.files.map(file => 'patch' in file ? {...file, locateBlock: locateFor(file.path, pr.head.sha)} : file) : pr.files}
                     renderBlock={renderBlock} locale={locale} rememberAs={`${name}#${pr.number}`}/>
             </>}
@@ -136,8 +236,18 @@ function PullRequests({name, labels, locale, renderBlock, locateFor, openTabs}:
     </div>;
 }
 
-export function PullRequestReviewPanel({repository, locale, renderBlock, locateFor, openTabs}: {
+export function PullRequestReviewPanel({repository, locale, renderBlock, locateFor, openTabs, connection, openLocally}: {
     repository: Repository; locale: string; renderBlock: ProjectBlockRenderer;
+    /**
+     * While connected, pull request contents are fetched over Git Smart HTTP (`refs/pull/<number>/head`) and compared
+     * from local Git objects, so private repositories can be reviewed. Without it, the public GitHub API is read.
+     */
+    connection?: PullRequestConnection;
+    /**
+     * Offers to open a pull request read over the connection in the work tree, on the branch `pr/<number>`. Pull
+     * requests read from the public API have no local objects, so the button is not shown for them.
+     */
+    openLocally?: PullRequestOpenLocally;
     /** Opens a pull request's project changes as tabs of the host's layout. */
     openTabs?: OpenTabs;
     /** Returns a locator for a project file whose PR head matches the open project, or `undefined`. */
@@ -156,5 +266,6 @@ export function PullRequestReviewPanel({repository, locale, renderBlock, locateF
     }, [repository]);
     if (origin?.repository !== repository) return <p role="status" className="twgit-context">{labels.loading}</p>;
     if (!origin.name) return <p className="twgit-context" role="status">{origin.failed ? labels.failed : labels.noOrigin}</p>;
-    return <PullRequests key={origin.name} name={origin.name} labels={labels} locale={locale} renderBlock={renderBlock} locateFor={locateFor} openTabs={openTabs}/>;
+    return <PullRequests key={origin.name} name={origin.name} labels={labels} locale={locale} renderBlock={renderBlock} locateFor={locateFor} openTabs={openTabs}
+        repository={repository} connection={connection} openLocally={openLocally}/>;
 }

package/src/remote-operations.ts

@@ -8,6 +8,89 @@ export type RemoteOperation = 'fetch' | 'pull' | 'push';
 export type RemoteSession = NonNullable<Awaited<ReturnType<GitSmartHttpOptions['getSession']>>>;
 export type GetRemoteSession = (remote: string, write: boolean) => Promise<RemoteSession | null>;
 
+type GitOptions = {fs: ReturnType<typeof createMutationFs>['fs']; dir: string; gitdir: string; cache: object};
+const sessionCodes = ['SESSION_REQUIRED', 'SESSION_UNAVAILABLE', 'SESSION_EXPIRED', 'REAUTH_REQUIRED', 'INVALID_SESSION'];
+
+// Fetch writes remote-tracking refs through these refspecs; anything else could land a ref outside refs/remotes/origin.
+async function checkRefspecs(options: GitOptions) {
+    const refspecs = await git.getConfigAll({...options, path: 'remote.origin.fetch'});
+    if (refspecs.some(spec => !/^\+?refs\/heads\/[^:\s]+:refs\/remotes\/origin\/[^:\s]+$/u.test(spec)))
+        throw new GitPanelError('unsupported');
+}
+
+/**
+ * Where a fetched pull request head is kept: outside `refs/heads`, `refs/remotes` and `refs/tags`, so Git CLI lists it
+ * with `git for-each-ref refs/pull` and `git log --all` but not as a branch or tag, `git fetch --prune` leaves it alone,
+ * and `git gc` keeps its objects. Each fetch of the same pull request replaces it.
+ */
+export const pullRequestRef = (number: number) => `refs/pull/origin/${number}/head`;
+
+export interface PullRequestFetch {
+    readonly number: number;
+    /** The commit at GitHub's `refs/pull/<number>/head`, kept locally at `ref`. */
+    readonly head: string;
+    readonly ref: string;
+    /** GitHub's default branch, from the advertised `HEAD`, or `null` when it is not advertised. */
+    readonly defaultBranch: string | null;
+    /** The branches on GitHub, as `refs/remotes/origin/<name>` after this fetch. */
+    readonly branches: readonly string[];
+}
+
+/**
+ * Fetches GitHub's `refs/pull/<number>/head` together with every branch, over the connection's Git Smart HTTP, like
+ * `git fetch origin refs/pull/<number>/head`. The branches update `refs/remotes/origin/*` as fetch does, and the head
+ * is kept at `pullRequestRef(number)`. The work tree, the index, HEAD and `.git/config` are never written. The writes
+ * are staged first and applied together, under the same lock as fetch, pull and push.
+ */
+export async function runPullRequestFetch(root: FileSystemDirectoryHandle, number: number,
+    getSession: GetRemoteSession, guard: () => void, signal?: AbortSignal): Promise<PullRequestFetch> {
+    if (!Number.isSafeInteger(number) || number < 1) throw new GitPanelError('pullRequestNotFound');
+    const execute = async () => {
+        guard();
+        const transaction = createMutationFs(root, false);
+        const options = {fs: transaction.fs, dir: '/', gitdir: '/.git', cache: {}};
+        const remote = await git.getConfig({...options, path: 'remote.origin.url'});
+        if (typeof remote !== 'string') throw new GitPanelError('session');
+        await checkRefspecs(options);
+        const session = await getSession(remote, false);
+        if (!session) throw new GitPanelError('session');
+        guard();
+        const transport = createGitSmartHttp({remote, connection: session.connection,
+            getSession: () => getSession(remote, false), signal});
+        const source = `refs/pull/${number}/head`;
+        let result: Awaited<ReturnType<typeof git.fetch>>;
+        try {
+            result = await git.fetch({...options, ...transport, remote: 'origin', remoteRef: source, tags: false});
+        } catch (error) {
+            const {code, data} = error as {code?: string; data?: {what?: string}};
+            // isomorphic-git resolves the wanted ref against the advertisement before it sends any request for objects.
+            if (code === 'NotFoundError' && data?.what === source) throw new GitPanelError('pullRequestNotFound');
+            throw remoteError(error);
+        }
+        const head = result.fetchHead;
+        if (!head || !/^[0-9a-f]{40}$/u.test(head)) throw new GitPanelError('remoteFailed');
+        const ref = pullRequestRef(number);
+        await git.writeRef({...options, ref, value: head, force: true});
+        const branches = (await git.listBranches({...options, remote: 'origin'})).filter(name => name !== 'HEAD').sort();
+        const advertised = result.defaultBranch?.startsWith('refs/heads/') ? result.defaultBranch.slice(11) : null;
+        await transaction.commit(guard);
+        return {number, head, ref, defaultBranch: advertised && branches.includes(advertised) ? advertised : null, branches};
+    };
+    return globalThis.navigator?.locks ? navigator.locks.request('tw-plus-git-mutation', execute) : execute();
+}
+
+/** Maps a failed read from GitHub to what the person can act on: the connection, access, or the network. */
+function remoteError(error: unknown) {
+    if (error instanceof GitPanelError) return error;
+    if (error instanceof GitSmartHttpError) {
+        if (sessionCodes.includes(error.code)) return new GitPanelError('session');
+        if (error.code === 'FORBIDDEN') return new GitPanelError('forbidden');
+        if (['NETWORK_ERROR', 'UPSTREAM_FAILURE', 'UPSTREAM_TIMEOUT', 'RATE_LIMITED'].includes(error.code))
+            return new GitPanelError('network');
+    }
+    return new GitPanelError('remoteFailed');
+}
+
 export async function runRemoteOperation(root: FileSystemDirectoryHandle, operation: RemoteOperation,
     getSession: GetRemoteSession, guard: () => void, signal?: AbortSignal) {
     const execute = async () => {
@@ -23,9 +106,7 @@ export async function runRemoteOperation(root: FileSystemDirectoryHandle, operat
         const trackingRef = await config('branch.' + ref + '.merge');
         if ((trackingRemote && trackingRemote !== 'origin') || (trackingRef && !trackingRef.startsWith('refs/heads/')))
             throw new GitPanelError('unsupported');
-        const refspecs = await git.getConfigAll({...options, path: 'remote.origin.fetch'});
-        if (refspecs.some(spec => !/^\+?refs\/heads\/[^:\s]+:refs\/remotes\/origin\/[^:\s]+$/u.test(spec)))
-            throw new GitPanelError('unsupported');
+        await checkRefspecs(options);
         if (operation === 'pull') {
             if ((await git.statusMatrix({...options, refresh: false})).some(([, head, worktree, stage]) =>
                 head !== worktree || head !== stage)) throw new GitPanelError('pullUnsafe');

package/src/repository.ts

@@ -1,7 +1,9 @@
 import * as git from 'isomorphic-git';
 import {createTwoFilesPatch} from 'diff';
 import {createReadOnlyFs, errorCode, GitPanelError, pathParts, readOptional, sameBytes} from './filesystem.js';
-import {runRemoteOperation} from './remote-operations.js';
+import {runPullRequestFetch, runRemoteOperation} from './remote-operations.js';
+import {createProjectSourceDiff} from './project-source-patch.js';
+import type {ProjectSourceReviewFile} from './project-source-review.js';
 import {runLocalOperation} from './local-operations.js';
 import type {LocalOperation} from './local-operations.js';
 import type {GetRemoteSession, RemoteOperation} from './remote-operations.js';
@@ -9,6 +11,8 @@ import {assetLimit, assetsDirectoryParts, folderSettingsLimit, isAssetName} from
 import type {ProjectAssetLoader, ProjectVersion} from './project-assets.js';
 
 export {createReadOnlyFs, GitPanelError} from './filesystem.js';
+export {pullRequestRef} from './remote-operations.js';
+export type {PullRequestFetch} from './remote-operations.js';
 export type ChangeGroup = 'staged' | 'unstaged' | 'untracked' | 'commit';
 export interface FileChange {
     path: string;
@@ -21,6 +25,22 @@ export interface FileChange {
     /** For `commit` changes, the commit compared with its first parent. */
     commit?: string;
 }
+/** A version of the pull request's base to compare with: GitHub's base commit when known, else a branch on origin. */
+export interface PullRequestBase {
+    /** The base commit GitHub reported, used when the fetch brought it. */
+    sha?: string;
+    /** The base branch, read from `refs/remotes/origin/<branch>` when `sha` is missing or not local. */
+    branch?: string;
+}
+export interface PullRequestFiles {
+    /** The base that was compared: the branch it was named by, if any, and its commit. */
+    base: {ref: string | null; sha: string};
+    head: string;
+    /** The merge base of `base.sha` and `head`, like GitHub's three-dot comparison; `null` for unrelated histories. */
+    mergeBase: string | null;
+    /** Every changed path from the merge base to the head, with project data as a project-source diff. */
+    files: ProjectSourceReviewFile[];
+}
 export interface Commit {
     oid: string;
     message: string;
@@ -64,6 +84,8 @@ export interface HistoryPage {
 export const historyPageSize = 50;
 const projectSourceLimit = 16 * 1024 * 1024;
 type Metadata = Map<string, Uint8Array | null>;
+/** The branch fields of a snapshot. */
+export type BranchRefs = Pick<Snapshot, 'branch' | 'head' | 'branches' | 'remoteBranches'>;
 export interface Snapshot {
     branch: string | undefined;
     head: string | null;
@@ -105,6 +127,9 @@ export interface FileDiff {
     tooLarge: boolean;
 }
 const emptyTree = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+const isSha = (value: unknown): value is string => typeof value === 'string' && /^[0-9a-f]{40}$/u.test(value);
+const validBranch = (name: string) => /^[^\s~^:?*[\\]+$/u.test(name) && !name.startsWith('/') && !name.endsWith('/') &&
+    !name.endsWith('.lock') && !name.includes('..') && !name.includes('//') && !name.includes('@{');
 const textLimit = 1024 * 1024;
 const inScope = (path: string, scope: string) => !scope || path === scope || path.startsWith(scope + '/');
 // Above this many work-tree files, probes only watch Git metadata. Edits then need a manual refresh.
@@ -275,13 +300,7 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
     const assertSnapshot = async (snapshot: Snapshot) => {
         if (!sameMetadata(snapshot.metadata, await metadata())) throw new GitPanelError('changed');
     };
-    const read = async (scope = ''): Promise<Snapshot> => {
-        scope = pathParts(scope).join('/');
-        fs.clearReads();
-        cache = {};
-        // Taken first, so a change during the read differs from the stored value and triggers another read.
-        const fingerprint = await probe(scope);
-        const before = await metadata();
+    const readRefs = async (): Promise<BranchRefs> => {
         let head: string | null;
         try {head = await git.resolveRef({...options, ref: 'HEAD'});} catch (error) {
             if (errorCode(error) !== 'NotFoundError') throw error;
@@ -291,6 +310,16 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
         const branches = await git.listBranches(options);
         const remoteBranches = (await git.listBranches({...options, remote: 'origin'}))
             .filter(name => name !== 'HEAD' && !branches.includes(name)).sort();
+        return {branch: branch || undefined, head, branches, remoteBranches};
+    };
+    const read = async (scope = ''): Promise<Snapshot> => {
+        scope = pathParts(scope).join('/');
+        fs.clearReads();
+        cache = {};
+        // Taken first, so a change during the read differs from the stored value and triggers another read.
+        const fingerprint = await probe(scope);
+        const before = await metadata();
+        const {branch, head, branches, remoteBranches} = await readRefs();
         const commits = head ? (await git.log({...options, cache, ref: head, depth: 50})).map(({oid, commit}) => ({
             oid, message: commit.message, author: commit.author.name, timestamp: commit.author.timestamp
         })) : [];
@@ -316,7 +345,7 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
         }
         if (!sameMetadata(before, await metadata())) throw new GitPanelError('changed');
         await fs.checkReads();
-        return {branch: branch || undefined, head, branches, remoteBranches, commits, changes, scope, metadata: before, probe: fingerprint,
+        return {branch, head, branches, remoteBranches, commits, changes, scope, metadata: before, probe: fingerprint,
             upstream};
     };
     interface HistoryNode {commit: HistoryCommit; time: number; children: number; expanded: boolean}
@@ -551,6 +580,100 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
         await fs.checkReads();
         return {before: before.source, after: after.source, assetsDirectory: {before: before.assetsDirectory, after: after.assetsDirectory}};
     };
+    const hasCommit = async (oid: string) => {
+        try {
+            await git.readCommit({...options, cache, oid});
+            return true;
+        } catch {
+            return false;
+        }
+    };
+    type TreeChange = {path: string; before: Entry | null; after: Entry | null};
+    /** Lists the paths that differ between two trees, skipping subtrees with the same object. */
+    const treeChanges = async (before: string, after: string): Promise<TreeChange[]> => {
+        const file = async (entry: git.WalkerEntry | null) => entry && await entry.type() !== 'tree' ?
+            {oid: await entry.oid(), mode: await entry.mode()} : null;
+        const changes = await git.walk({...options, cache, trees: [git.TREE({ref: before}), git.TREE({ref: after})],
+            map: async (path, [a, b]) => {
+                if (path === '.') return;
+                if (a && b && await a.oid() === await b.oid() && await a.mode() === await b.mode()) return null;
+                const change = {path, before: await file(a), after: await file(b)};
+                // A tree on either side is walked on; a file on the other side is a change of its own.
+                return change.before || change.after ? change : undefined;
+            }}) as TreeChange[];
+        return changes.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+    };
+    const readBlobText = async (entry: Entry | null) => {
+        if (!entry) return '{"targets":[]}\n';
+        if (entry.mode !== 0o100644 && entry.mode !== 0o100755) throw new GitPanelError('unsupported');
+        const {blob} = await git.readBlob({...options, cache, oid: entry.oid});
+        if (blob.byteLength > projectSourceLimit) throw new GitPanelError('large');
+        return new TextDecoder('utf-8', {fatal: true}).decode(blob);
+    };
+    const readTreeAsset = async (ref: string, folder: string[], md5ext: string, signal: AbortSignal) => {
+        if (signal.aborted) return null;
+        const source: Source = {kind: 'tree', ref};
+        const settings = await readVersion(source, [...folder, 'sb3-source.json'].join('/'), folderSettingsLimit);
+        const directory = assetsDirectoryParts(settings && new TextDecoder().decode(settings));
+        if (!directory || signal.aborted) return null;
+        const bytes = await readVersion(source, [...folder, ...directory, md5ext].join('/'), assetLimit);
+        return bytes && !signal.aborted ? new Blob([bytes as Uint8Array<ArrayBuffer>]) : null;
+    };
+    const pullRequestAssets = (versions: Record<ProjectVersion, {ref: string; path: string} | null>): ProjectAssetLoader =>
+        ({version, md5ext, signal}) => {
+            const location = versions[version];
+            if (!location || !isAssetName(md5ext) || signal.aborted) return Promise.resolve(null);
+            return serial(() => readTreeAsset(location.ref, pathParts(location.path).slice(0, -1), md5ext, signal)).catch(() => null);
+        };
+    /** Compares a fetched pull request head with its merge base, from local Git objects only. */
+    const readPullRequest = async (head: string, base: PullRequestBase): Promise<PullRequestFiles> => {
+        if (!isSha(head) || !await hasCommit(head)) throw new GitPanelError('pullRequestNotFound');
+        let sha: string | undefined;
+        if (isSha(base.sha) && await hasCommit(base.sha)) sha = base.sha;
+        else if (base.branch !== undefined && validBranch(base.branch)) {
+            try {
+                sha = await git.resolveRef({...options, ref: 'refs/remotes/origin/' + base.branch});
+            } catch {
+                // Reported below.
+            }
+        }
+        if (!sha || !await hasCommit(sha)) throw new GitPanelError('baseMissing');
+        const [mergeBase = null] = await git.findMergeBase({...options, cache, oids: [sha, head]}) as string[];
+        const changes = await treeChanges(mergeBase ?? emptyTree, head);
+        // Pair a removed and an added file with the same content as a rename, like GitHub's exact renames.
+        const added = new Map<string, TreeChange[]>();
+        for (const change of changes) if (!change.before && change.after) added.set(change.after.oid, [...added.get(change.after.oid) ?? [], change]);
+        const renamed = new Map<TreeChange, TreeChange>();
+        for (const change of changes) {
+            const candidates = change.before && !change.after ? added.get(change.before.oid) : undefined;
+            const target = candidates?.find(candidate => !renamed.has(candidate));
+            if (target) renamed.set(target, change);
+        }
+        const removedByRename = new Set(renamed.values());
+        const files: ProjectSourceReviewFile[] = [];
+        for (const change of changes) {
+            if (removedByRename.has(change)) continue;
+            const from = renamed.get(change);
+            const before = from?.before ?? change.before;
+            const previousPath = from?.path;
+            const status = !before ? 'added' : !change.after ? 'removed' : 'updated';
+            if (change.path.split('/').pop() !== 'project.source.json') {
+                files.push({path: change.path, previousPath, status});
+                continue;
+            }
+            try {
+                const patch = createProjectSourceDiff(await readBlobText(before), await readBlobText(change.after));
+                const loadAsset = pullRequestAssets({
+                    before: before && mergeBase ? {ref: mergeBase, path: previousPath ?? change.path} : null,
+                    after: change.after ? {ref: head, path: change.path} : null
+                });
+                files.push({path: change.path, previousPath, patch, loadAsset});
+            } catch {
+                files.push({path: change.path, previousPath, status, unavailable: true});
+            }
+        }
+        return {base: {ref: base.branch ?? null, sha}, head, mergeBase, files};
+    };
     const directoryAt = async (path: string) => {
         let directory = root;
         for (const part of pathParts(path)) directory = await directory.getDirectoryHandle(part);
@@ -595,6 +718,21 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
                     throw error;
                 }
             }),
+        /**
+         * Fetches a pull request's head (`refs/pull/<number>/head`, which also covers pull requests from forks) and every
+         * branch over the connection; see `runPullRequestFetch`. Only Git objects and refs are written.
+         */
+        fetchPullRequest: (number: number, getSession: GetRemoteSession, guard: () => void, signal?: AbortSignal) =>
+            serial(async () => {
+                const result = await runPullRequestFetch(root, number, getSession, guard, signal);
+                cache = {};
+                return result;
+            }),
+        /**
+         * Reads the changes of a fetched pull request head against a base, from local Git objects: the changed paths
+         * from the merge base to the head, and each project file's diff with assets read from the same commits.
+         */
+        readPullRequest: (head: string, base: PullRequestBase) => serial(() => readPullRequest(head, base)),
         /** Stages, unstages or commits; see `runLocalOperation`. `guard` throws to stop before each write. */
         localOperation: (operation: LocalOperation, guard: () => void) =>
             serial(() => runLocalOperation(root, operation, guard)),
@@ -613,6 +751,14 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
             }
         }),
         read: (scope?: string) => serial(() => read(scope)),
+        /**
+         * The current branch, HEAD and the branch names, read from refs only. Cheap enough to follow branch changes made
+         * by other tools while nothing else is read; `read` returns the same fields.
+         */
+        refs: () => serial(() => {
+            fs.clearReads();
+            return readRefs();
+        }),
         readDiff: (snapshot: Snapshot, change: FileChange) => serial(() => readDiff(snapshot, change)),
         historyChanges: (snapshot: Snapshot, oid: string) => serial(() => historyChanges(snapshot, oid)),
         /**

package/src/style.css

@@ -92,3 +92,31 @@
 .twgit-graph-status { margin: 4px 0; font-size: 11px; min-height: 1em; }
 .twgit-panel .twgit-graph-popup [role="menuitem"]:focus-visible, .twgit-graph-popup [role="menuitem"]:focus-visible { outline-offset: -2px; }
 .twgit-graph-form-error { margin: 0; color: #a11919; overflow-wrap: anywhere; }
+/* The branch button sits in the host's menu bar and takes its text color; its menu uses the host's menu colors. */
+.twgit-branch-entry { position: relative; flex: 0 1 auto; align-self: center; display: flex; min-width: 0; font: inherit; }
+.twgit-branch-button { display: flex; align-items: center; gap: 4px; min-width: 0; max-width: 16rem; min-height: 2rem; padding: 0 8px;
+    color: inherit; background: transparent; border: 0; border-radius: 4px; font: inherit; white-space: nowrap; cursor: pointer; }
+.twgit-branch-button:hover, .twgit-branch-button[aria-expanded="true"] { background: color-mix(in srgb, currentColor 15%, transparent); }
+.twgit-branch-button:focus-visible { outline: 2px solid currentColor; outline-offset: -2px; }
+.twgit-branch-icon { flex: none; }
+.twgit-branch-name { min-width: 0; overflow: hidden; text-overflow: ellipsis; }
+.twgit-branch-unborn { flex: none; font-size: 11px; opacity: .85; }
+.twgit-branch-caret { flex: none; font-size: 10px; }
+.twgit-branch-popup { position: absolute; z-index: 510; top: calc(100% + 4px); right: 0; display: grid; gap: 2px; min-width: 220px;
+    max-width: min(360px, 90vw); max-height: 70vh; overflow: auto; box-sizing: border-box; padding: 4px;
+    color: var(--text-primary, CanvasText); background: var(--ui-white, Canvas); border: 1px solid var(--ui-black-transparent, GrayText);
+    border-radius: 6px; box-shadow: 0 8px 24px #0004; font: 14px/1.5 system-ui, sans-serif; white-space: normal; }
+.twgit-branch-popup [role^="menuitem"] { display: flex; align-items: center; gap: 6px; width: 100%; padding: 6px 10px; color: inherit;
+    background: transparent; border: 0; border-radius: 4px; font: inherit; text-align: start; overflow-wrap: anywhere; cursor: pointer; }
+.twgit-branch-popup [role^="menuitem"]:hover, .twgit-branch-popup [role^="menuitem"]:focus-visible {
+    background: color-mix(in srgb, currentColor 12%, transparent); }
+.twgit-branch-popup [role^="menuitem"]:focus-visible { outline: 2px solid var(--looks-secondary, Highlight); outline-offset: -2px; }
+.twgit-branch-popup [aria-disabled="true"]:not([aria-checked="true"]) { opacity: .55; cursor: default; }
+.twgit-branch-popup [aria-checked="true"] { font-weight: 600; }
+.twgit-branch-popup [data-separator-before="true"] { margin-top: 3px; box-shadow: 0 -3px 0 -2px color-mix(in srgb, currentColor 25%, transparent); }
+.twgit-branch-check { flex: none; width: 1em; text-align: center; }
+.twgit-branch-popup form { display: grid; gap: 6px; padding: 6px; font-size: 12px; }
+.twgit-branch-popup form label { display: flex; flex-wrap: wrap; gap: 4px; align-items: center; }
+.twgit-branch-popup form input:not([type]) { flex: 1; min-width: 10em; font: inherit; }
+.twgit-branch-popup form button { color: inherit; background: transparent; border: 1px solid currentColor; border-radius: 4px; padding: 3px 8px; font: inherit; cursor: pointer; }
+.twgit-branch-popup form button:disabled { opacity: .5; cursor: default; }

package/test/smart-http-fixture.js

@@ -176,3 +176,23 @@ export function adapterOptions(fixture, bearer = 'fixture-write') {
         fetch: (url, init) => fetch(url, {...init, headers: {...Object.fromEntries(init.headers), Origin: 'https://editor.example.invalid'}})
     };
 }
+
+/**
+ * Publishes a pull request the way GitHub exposes it on the base repository: `refs/pull/<number>/head` points at the
+ * head commit. With `fork`, the head is committed in a separate clone and pushed only to that ref, so no branch of the
+ * base repository contains it.
+ */
+export async function publishPullRequest(fixture, number, {fork = false, branch = 'feature', from, edit}) {
+    const dir = from ?? join(fixture.root, fork ? `fork-${number}` : `branch-${number}`);
+    if (!from) {
+        git(fixture.root, 'clone', '-q', fixture.bare, dir);
+        if (!fork) git(dir, 'switch', '-q', '-c', branch);
+    }
+    await edit(dir);
+    git(dir, 'add', '-A');
+    git(dir, '-c', 'user.name=Contributor', '-c', 'user.email=contributor@example.invalid', 'commit', '-qm', `pull request ${number}`);
+    const head = git(dir, 'rev-parse', 'HEAD');
+    if (!fork) git(dir, 'push', '-q', '--force', fixture.bare, branch);
+    git(dir, 'push', '-q', fixture.bare, `+HEAD:refs/pull/${number}/head`);
+    return {dir, head};
+}