@kubohiroya/turbowarp-plus-editor-git 0.12.0 → 0.12.1

package/README.ja.md

@@ -16,6 +16,8 @@ Node.js 26 で `npm ci` と `npm test` を実行します。Vite でライブラ
 
 ## Smart HTTP アダプター
 
+`test/smart-http-fixture.js` は、`git-http-backend` を IPv4 のループバックで動かす検証用のフィクスチャです。Node.js の標準モジュールだけを使い、利用側のブラウザーテストが同じ版を使えるよう配布物に含めます。
+
 `@kubohiroya/turbowarp-plus-editor-git/smart-http` の `createGitSmartHttp` に、Git 設定から選んだ GitHub の HTTPS リモート、信頼済みの接続先（`mode` と `proxyOrigin`）、現在のプロキシセッションか `null` を返す関数を渡します。auth パッケージの `GitAuthProvider` を使えます。Git パッケージは必要なセッションの型だけを構造的に参照するため、読み取り専用パネルとアダプターは auth パッケージと独立してインストールできます。
 
 ```ts

package/README.md

@@ -16,6 +16,8 @@ The panel structure and local Git approach were informed by [duff](https://githu
 
 ## Smart HTTP adapter
 
+`test/smart-http-fixture.js` runs `git-http-backend` on the IPv4 loopback for tests. It uses only Node.js built-in modules and ships in the package so browser tests of a host use the fixture of the same version.
+
 Import `createGitSmartHttp` from `@kubohiroya/turbowarp-plus-editor-git/smart-http`. Pass the selected GitHub HTTPS remote from Git config, a trusted connection (`mode` and `proxyOrigin`), and a function that returns the current proxy session or `null`. A `GitAuthProvider` from the auth package satisfies this contract. The Git package uses the session fields structurally, so the read-only panel and the adapter can be installed independently of the auth package.
 
 ```ts

package/dist/index.js

@@ -3557,6 +3557,8 @@ function GitPanel({ vm, document, host, controller }) {
 	const alive = useRef(true);
 	const opening = useRef(false);
 	const dialog = useRef(null);
+	const shownRef = useRef(false);
+	const deferred = useRef(false);
 	const reviewing = useRef(review);
 	reviewing.current = review;
 	const handled = useRef(null);
@@ -3582,6 +3584,11 @@ function GitPanel({ vm, document, host, controller }) {
 		} catch (error) {
 			if (epoch.current !== ticket) return;
 			const code = error instanceof GitPanelError ? error.code : "failed";
+			if (automatic && code === "changed") {
+				handled.current = null;
+				setState((previous) => _objectSpread2$1(_objectSpread2$1({}, previous), {}, { busy: false }));
+				return;
+			}
 			const message = labels[code] || labels.failed;
 			setState((previous) => _objectSpread2$1(_objectSpread2$1({}, previous), {}, {
 				error: automatic && previous.error ? previous.error : message,
@@ -3590,6 +3597,7 @@ function GitPanel({ vm, document, host, controller }) {
 			}));
 		} finally {
 			running.current = false;
+			if (epoch.current !== ticket && !refreshPending.current && alive.current) setState((previous) => _objectSpread2$1(_objectSpread2$1({}, previous), {}, { busy: false }));
 			if (automatic) {
 				background.current = null;
 				settle();
@@ -3632,20 +3640,29 @@ function GitPanel({ vm, document, host, controller }) {
 	};
 	controller.refresh = async (automatic = false) => {
 		if (!alive.current || !current.current.repository) return;
+		if (!shownRef.current) {
+			deferred.current = true;
+			return;
+		}
 		if (running.current) {
 			if (!automatic) refreshPending.current = true;
 			return;
 		}
 		await run(async () => {
 			const { repository, project } = current.current;
-			const snapshot = await repository.read(project !== null && project !== void 0 ? project : "");
-			return {
-				snapshot,
-				changes: snapshot.changes,
-				selected: null,
-				diff: null,
-				commit: null
-			};
+			for (let attempt = 1;; attempt++) try {
+				const snapshot = await repository.read(project !== null && project !== void 0 ? project : "");
+				return {
+					snapshot,
+					changes: snapshot.changes,
+					selected: null,
+					diff: null,
+					commit: null
+				};
+			} catch (error) {
+				if (!(error instanceof GitPanelError && error.code === "changed") || attempt >= 5) throw error;
+				await new Promise((resolve) => setTimeout(resolve, 200 * attempt));
+			}
 		}, automatic);
 	};
 	useEffect(() => {
@@ -3662,7 +3679,7 @@ function GitPanel({ vm, document, host, controller }) {
 					selected: null,
 					diff: null,
 					commit: null,
-					busy: false
+					busy: running.current
 				}));
 				queueMicrotask(() => void controller.refresh());
 			}
@@ -3675,6 +3692,13 @@ function GitPanel({ vm, document, host, controller }) {
 			unsubscribe === null || unsubscribe === void 0 || unsubscribe();
 		};
 	}, [host]);
+	useEffect(() => {
+		shownRef.current = shown;
+		if (shown && deferred.current) {
+			deferred.current = false;
+			controller.refresh();
+		}
+	}, [shown]);
 	useEffect(() => {
 		const repository = state.repository;
 		if (!shown || !repository) return;
@@ -3683,7 +3707,8 @@ function GitPanel({ vm, document, host, controller }) {
 		let checking = false;
 		const check = async () => {
 			const { snapshot } = current.current;
-			if (stopped || checking || running.current || document.visibilityState === "hidden" || !snapshot || current.current.repository !== repository) return;
+			const hidden = !dialog.current || !dialog.current.getClientRects().length;
+			if (stopped || checking || running.current || document.visibilityState === "hidden" || hidden || !snapshot || current.current.repository !== repository) return;
 			checking = true;
 			try {
 				const probe = await repository.probe(snapshot.scope);
@@ -3978,6 +4003,7 @@ function GitPanel({ vm, document, host, controller }) {
 	}) : /* @__PURE__ */ React.createElement("p", null, labels.select))));
 	if (slot) return createPortal(/* @__PURE__ */ React.createElement("div", {
 		className: "twgit-panel twgit-panel-tab",
+		ref: dialog,
 		role: "region",
 		"aria-label": labels.title
 	}, content), slot.element);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubohiroya/turbowarp-plus-editor-git",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Read-only local Git panel for TurboWarp Plus Editor",
   "type": "module",
   "license": "MPL-2.0",
@@ -36,6 +36,7 @@
     "tsconfig.json",
     "README.ja.md",
     "THIRD_PARTY_NOTICES.md",
+    "test/smart-http-fixture.js",
     "README.md",
     "LICENSE"
   ],

package/src/index.tsx

@@ -93,6 +93,9 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
     const alive = useRef(true);
     const opening = useRef(false);
     const dialog = useRef<HTMLDivElement>(null);
+    // A closed panel reads nothing; a refresh asked while it is closed waits until it opens again.
+    const shownRef = useRef(false);
+    const deferred = useRef(false);
     const reviewing = useRef(review);
     reviewing.current = review;
     // The last fingerprint acted on, so a failing read or an open diff is not retried on every check.
@@ -115,10 +118,20 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
         } catch (error) {
             if (epoch.current !== ticket) return;
             const code = error instanceof GitPanelError ? error.code : 'failed';
+            // A background read that met another tool still writing tries again on the next check, without an alert.
+            if (automatic && code === 'changed') {
+                handled.current = null;
+                setState(previous => ({...previous, busy: false}));
+                return;
+            }
             const message = labels[code as keyof typeof labels] || labels.failed;
             setState(previous => ({...previous, error: automatic && previous.error ? previous.error : message, busy: false, diff: null}));
         } finally {
             running.current = false;
+            // A result dropped by a newer load still ends the busy state, unless a refresh follows at once.
+            if (epoch.current !== ticket && !refreshPending.current && alive.current) {
+                setState(previous => ({...previous, busy: false}));
+            }
             if (automatic) {background.current = null; settle();}
             if (refreshPending.current) {
                 refreshPending.current = false;
@@ -143,14 +156,26 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
     };
     controller.refresh = async (automatic = false) => {
         if (!alive.current || !current.current.repository) return;
+        if (!shownRef.current) {
+            deferred.current = true;
+            return;
+        }
         if (running.current) {
             if (!automatic) refreshPending.current = true;
             return;
         }
         await run(async () => {
             const {repository, project} = current.current;
-            const snapshot = await repository!.read(project ?? '');
-            return {snapshot, changes: snapshot.changes, selected: null, diff: null, commit: null};
+            // A save or a Git command may still be finishing its writes; read again briefly before reporting a change.
+            for (let attempt = 1; ; attempt++) {
+                try {
+                    const snapshot = await repository!.read(project ?? '');
+                    return {snapshot, changes: snapshot.changes, selected: null, diff: null, commit: null};
+                } catch (error) {
+                    if (!(error instanceof GitPanelError && error.code === 'changed') || attempt >= 5) throw error;
+                    await new Promise(resolve => setTimeout(resolve, 200 * attempt));
+                }
+            }
         }, automatic);
     };
     useEffect(() => {
@@ -159,13 +184,21 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
             setDirty(host.isProjectDirty());
             if (event === 'loaded' && !opening.current) {
                 epoch.current++;
+                // An operation still running stays busy; its end, or the refresh queued after it, clears the flag.
                 setState(previous => ({...previous, project: null, snapshot: null, changes: [],
-                    selected: null, diff: null, commit: null, busy: false}));
+                    selected: null, diff: null, commit: null, busy: running.current}));
                 queueMicrotask(() => void controller.refresh());
             }
         });
         return () => {alive.current = false; epoch.current++; remoteRequest.current?.abort(); unsubscribe?.();};
     }, [host]);
+    useEffect(() => {
+        shownRef.current = shown;
+        if (shown && deferred.current) {
+            deferred.current = false;
+            void controller.refresh();
+        }
+    }, [shown]);
     // While the panel is open, notice Git commands, agents and editors that change the repository outside the Editor.
     useEffect(() => {
         const repository = state.repository;
@@ -175,7 +208,9 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
         let checking = false;
         const check = async () => {
             const {snapshot} = current.current;
-            if (stopped || checking || running.current || document.visibilityState === 'hidden' ||
+            // A tab behind another one has no boxes; it reads again when it is shown.
+            const hidden = !dialog.current || !dialog.current.getClientRects().length;
+            if (stopped || checking || running.current || document.visibilityState === 'hidden' || hidden ||
                 !snapshot || current.current.repository !== repository) return;
             checking = true;
             try {
@@ -409,7 +444,7 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
             </div>}
     </>;
     // In a tab the Editor stays usable beside the panel, so there is no backdrop, focus trap or Escape to close.
-    if (slot) return createPortal(<div className="twgit-panel twgit-panel-tab" role="region" aria-label={labels.title}>{content}</div>,
+    if (slot) return createPortal(<div className="twgit-panel twgit-panel-tab" ref={dialog} role="region" aria-label={labels.title}>{content}</div>,
         slot.element);
     return <div className="twgit-backdrop">
         <div className="twgit-panel" ref={dialog} tabIndex={-1} role="dialog" aria-modal="true" aria-label={labels.title}

package/test/smart-http-fixture.js

@@ -0,0 +1,178 @@
+import {execFileSync} from 'node:child_process';
+import {createServer} from 'node:http';
+import {once} from 'node:events';
+import {randomUUID} from 'node:crypto';
+import {mkdtemp, mkdir, rm, writeFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+
+// Git's detached auto maintenance can repack loose objects while the code under test is reading them.
+const gitEnv = {...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_COUNT: '2',
+    GIT_CONFIG_KEY_0: 'maintenance.auto', GIT_CONFIG_VALUE_0: 'false', GIT_CONFIG_KEY_1: 'gc.auto', GIT_CONFIG_VALUE_1: '0'};
+const backend = join(execFileSync('git', ['--exec-path'], {encoding: 'utf8'}).trim(), 'git-http-backend');
+export const remote = 'https://github.com/fixture/work.git';
+export const readDiscovery = '/info/refs?service=git-upload-pack';
+export const writeDiscovery = '/info/refs?service=git-receive-pack';
+const routePrefix = '/v1/git/fixture/work.git';
+const maxBody = 1024 * 1024;
+const pushIdPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+
+export function git(dir, ...args) {
+    return execFileSync('git', args, {cwd: dir, encoding: 'utf8', env: gitEnv, stdio: ['ignore', 'pipe', 'pipe']}).trim();
+}
+
+export function commit(dir, message) {
+    git(dir, 'add', 'project.txt');
+    git(dir, '-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', 'commit', '-qm', message);
+    return git(dir, 'rev-parse', 'HEAD');
+}
+
+export async function startFixture(t) {
+    const root = await mkdtemp(join(tmpdir(), 'tw-git-http-'));
+    t.after(() => rm(root, {recursive: true, force: true}));
+    await mkdir(join(root, 'fixture'));
+    const bare = join(root, 'fixture/work.git');
+    const seed = join(root, 'seed');
+    const client = join(root, 'client');
+    git(root, 'init', '-q', '--bare', '-b', 'main', bare);
+    git(bare, 'config', 'http.receivepack', 'true');
+    git(root, 'init', '-q', '-b', 'main', seed);
+    await writeFile(join(seed, 'project.txt'), 'initial\n');
+    commit(seed, 'initial');
+    git(seed, 'push', bare, 'main');
+    git(root, 'clone', '-q', bare, client);
+    git(client, 'remote', 'set-url', 'origin', remote);
+    git(client, 'config', 'http.corsProxy', 'https://rejected.example.invalid');
+
+    const origins = new Set(['https://editor.example.invalid']);
+    const sessions = new Map([
+        ['fixture-read', {write: false, mode: 'desktop'}],
+        ['fixture-write', {write: true, mode: 'desktop'}],
+        ['fixture-expired', {expires: true}],
+        ['fixture-cloudflare', {write: true, mode: 'cloudflare'}]
+    ]);
+    const requests = [];
+    const upstream = [];
+    const pushIds = new WeakMap();
+    const fixture = {root, bare, seed, client, origins, sessions, requests, upstream, redirect: false, dropPush: false};
+    const reply = (res, status, code) => {
+        res.writeHead(status, {'Content-Type': 'application/json'});
+        res.end(JSON.stringify({code, requestId: randomUUID()}));
+    };
+
+    async function handle(req, res) {
+        const {url, method, headers} = req;
+        requests.push({url, method, headers});
+        if (headers.host !== new URL(fixture.origin).host || req.socket.remoteAddress !== '127.0.0.1' ||
+            !origins.has(headers.origin)) return reply(res, 403, 'FORBIDDEN');
+
+        res.setHeader('Access-Control-Allow-Origin', headers.origin);
+        res.setHeader('Vary', 'Origin, Access-Control-Request-Method, Access-Control-Request-Headers');
+        res.setHeader('Cache-Control', 'no-store');
+        const effectiveMethod = method === 'OPTIONS' ? headers['access-control-request-method'] : method;
+        const path = url.startsWith(routePrefix + '/') ? url.slice(routePrefix.length) : '';
+        const service = ['git-upload-pack', 'git-receive-pack'].find(service =>
+            (effectiveMethod === 'GET' && path === '/info/refs?service=' + service) ||
+            (effectiveMethod === 'POST' && path === '/' + service));
+        if (!service) return reply(res, 400, 'BAD_REQUEST');
+        const push = effectiveMethod === 'POST' && service === 'git-receive-pack';
+        const requestType = 'application/x-' + service + '-request';
+        if (method === 'OPTIONS') {
+            const allowed = effectiveMethod === 'GET' ? ['authorization'] : ['authorization', 'content-type'];
+            if (push) allowed.push('git-push-id');
+            const asked = (headers['access-control-request-headers'] ?? '').toLowerCase().split(',').map(name => name.trim());
+            if (asked.some(name => !allowed.includes(name))) return reply(res, 403, 'FORBIDDEN');
+            res.writeHead(204, {'Access-Control-Allow-Methods': effectiveMethod, 'Access-Control-Allow-Headers': allowed.join(', ')});
+            return res.end();
+        }
+        const session = headers.authorization?.startsWith('Bearer ') && sessions.get(headers.authorization.slice(7));
+        if (!session) return reply(res, 401, 'SESSION_REQUIRED');
+        if (session.expires) return reply(res, 401, 'SESSION_EXPIRED');
+        if (session.mode !== 'desktop' || (service === 'git-receive-pack' && !session.write)) return reply(res, 403, 'FORBIDDEN');
+        if (fixture.redirect) {
+            if (fixture.redirect === 'upstream') return reply(res, 409, 'REDIRECT_REJECTED');
+            res.writeHead(307, {Location: fixture.origin + '/redirect-target'});
+            return res.end();
+        }
+
+        let input;
+        if (method === 'POST') {
+            if (headers['content-type'] !== requestType) return reply(res, 400, 'BAD_REQUEST');
+            if (!/^\d+$/u.test(headers['content-length'] ?? '')) return reply(res, 411, 'LENGTH_REQUIRED');
+            const expected = Number(headers['content-length']);
+            if (expected > maxBody) return reply(res, 413, 'PAYLOAD_TOO_LARGE');
+            let size = 0;
+            const chunks = [];
+            for await (const chunk of req) {
+                size += chunk.length;
+                if (size > expected) return reply(res, 400, 'BAD_REQUEST');
+                chunks.push(chunk);
+            }
+            if (size !== expected) return reply(res, 400, 'BAD_REQUEST');
+            input = Buffer.concat(chunks);
+        }
+        const pushId = headers['git-push-id'];
+        if (push ? !pushIdPattern.test(pushId ?? '') || req.headersDistinct['git-push-id']?.length !== 1 :
+            pushId !== undefined) return reply(res, 400, 'BAD_REQUEST');
+        if (push) {
+            let claimed = pushIds.get(session);
+            if (!claimed) {
+                claimed = new Set();
+                pushIds.set(session, claimed);
+            }
+            if (claimed.has(pushId)) return reply(res, 409, 'PUSH_DUPLICATE');
+            claimed.add(pushId);
+        }
+
+        const [pathInfo, query = ''] = ('/fixture/work.git' + path).split('?');
+        // Model the credential boundary and invoke Git's CGI backend locally.
+        const authorization = 'Basic ' + Buffer.from('x-access-token:fixture-upstream-token').toString('base64');
+        upstream.push({method, path: pathInfo, query, authorization});
+        const output = execFileSync(backend, [], {
+            input,
+            env: {...gitEnv, GIT_PROJECT_ROOT: root, GIT_HTTP_EXPORT_ALL: '1', REQUEST_METHOD: method,
+                PATH_INFO: pathInfo, QUERY_STRING: query, REMOTE_USER: 'fixture-user',
+                CONTENT_TYPE: headers['content-type'] ?? '', CONTENT_LENGTH: headers['content-length'] ?? '0'}
+        });
+        const dropPush = fixture.dropPush && method === 'POST' && service === 'git-receive-pack';
+        if (dropPush && fixture.dropPush !== 'after-headers') {
+            res.destroy();
+            return;
+        }
+        const end = output.indexOf('\r\n\r\n');
+        if (end < 0) throw new Error('Git CGI response had no header boundary');
+        const lines = output.subarray(0, end).toString().split('\r\n');
+        const statusLine = lines.find(line => line.startsWith('Status: '));
+        const contentType = lines.find(line => line.startsWith('Content-Type: '));
+        if (contentType) res.setHeader('Content-Type', contentType.slice(14));
+        if (dropPush) {
+            res.setHeader('Content-Length', output.length - end - 3);
+            res.setHeader('Connection', 'close');
+        }
+        res.writeHead(statusLine ? Number(statusLine.slice(8, 11)) : 200);
+        res.end(output.subarray(end + 4));
+    }
+
+    const server = createServer((req, res) => {
+        handle(req, res).catch(() => {
+            if (!res.headersSent) reply(res, 502, 'UPSTREAM_FAILURE');
+            else res.destroy();
+        });
+    });
+    server.listen(0, '127.0.0.1');
+    await once(server, 'listening');
+    t.after(() => new Promise(resolve => {server.close(resolve); server.closeAllConnections();}));
+    fixture.origin = 'http://127.0.0.1:' + server.address().port;
+    return fixture;
+}
+
+export const proxyPath = path => routePrefix + path;
+
+export function adapterOptions(fixture, bearer = 'fixture-write') {
+    const connection = {mode: 'desktop', proxyOrigin: fixture.origin};
+    return {
+        remote, connection,
+        getSession: async () => ({connection, bearer, expiresAt: Date.now() + 60_000}),
+        fetch: (url, init) => fetch(url, {...init, headers: {...Object.fromEntries(init.headers), Origin: 'https://editor.example.invalid'}})
+    };
+}