git-reviewer 2.8.0 → 2.9.0

package/README.md

@@ -3,7 +3,7 @@
 [![CI](https://github.com/dheerajjha/reviewer/actions/workflows/ci.yml/badge.svg)](https://github.com/dheerajjha/reviewer/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](package.json)
-[![Tests](https://img.shields.io/badge/tests-284-brightgreen.svg)](test/)
+[![Tests](https://img.shields.io/badge/tests-291-brightgreen.svg)](test/)
 [![Dependencies](https://img.shields.io/badge/dependencies-3-brightgreen.svg)](package.json)
 
 When an agent writes the code, reading it becomes the bottleneck — and the tool
@@ -294,7 +294,7 @@ rather than a public issue.
 
 ```bash
 npm install           # 3 dependencies, no build step, ~6MB
-npm test              # 284 tests
+npm test              # 291 tests
 npm run test:watch
 npm run test:coverage
 ```

package/bin/reviewer.js

@@ -226,9 +226,25 @@ async function main() {
     stop();
   };
 
+  /**
+   * The last tab closed and did not come back.
+   *
+   * Only on a terminal. In the piped form, submitting is what hands the
+   * review over, and a closed tab is not a submitted review -- wiring this to
+   * the handoff would send a half-written review to something that starts
+   * editing files, which is a worse outcome by a wide margin than the Ctrl+C
+   * this saves.
+   */
+  const onIdle = handingOff
+    ? null
+    : () => {
+      note('\n  Browser closed. Stopping.\n');
+      stop();
+    };
+
   const server = await listen(
     options.port ?? (Number(process.env.PORT) || DEFAULT_PORT),
-    { onReviewSubmitted, handoff: handingOff }
+    { onReviewSubmitted, handoff: handingOff, onIdle }
   );
   const url = buildUrl(`http://${DEFAULT_HOST}:${server.address().port}`, repoPath);
 
@@ -236,7 +252,7 @@ async function main() {
   if (repoPath) note(`  reviewing      ${repoPath}`);
   note(handingOff
     ? '\n  Submit the review in the browser and it will be written here.\n'
-    : '\n  Press Ctrl+C to stop.\n');
+    : '\n  Close the tab when you are done, or press Ctrl+C.\n');
 
   if (options.open && !(await openInBrowser(url))) {
     note('  Could not open a browser — open the URL above yourself.\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-reviewer",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "Review your coding agent's changes like a pull request — locally, with inline comments and threaded follow-ups, then hand the marked-up review back to the agent",
   "author": "Dheeraj Jha",
   "license": "MIT",

package/public/app.js

@@ -222,6 +222,17 @@ async function loadRepo() {
 }
 
 // Display list of changed files
+function fileStatusClass(status) {
+  switch (status) {
+    case 'A': return 'file-status-added';
+    case 'D': return 'file-status-deleted';
+    case 'R': return 'file-status-renamed';
+    case 'B': return 'file-status-binary';
+    case 'M':
+    default: return 'file-status-modified';
+  }
+}
+
 function displayFiles(files) {
   const sidebar = document.getElementById('sidebar');
   const filesList = document.getElementById('filesList');
@@ -244,7 +255,7 @@ function displayFiles(files) {
     const displayText = path
       ? `${escapeHtml(path)}/<span class="filename">${escapeHtml(filename)}</span>`
       : `<span class="filename">${escapeHtml(filename)}</span>`;
-    const statusClass = status === 'A' ? 'file-status-added' : 'file-status-modified';
+    const statusClass = fileStatusClass(status);
     const statusBadge = `<span class="file-status ${statusClass}">${status}</span>`;
 
     // The row used to carry the file name itself, inside a string literal
@@ -1707,7 +1718,31 @@ function getKeyboardShortcut(key, targetTagName, modifiers = {}) {
 }
 
 // Allow Enter key to load repo
+/**
+ * Tell the server this tab exists, by holding a connection open for as long
+ * as it does.
+ *
+ * There is nothing to read from this stream. The point is the socket: the
+ * browser closes it when the tab closes, which is the only notification of a
+ * closed tab that arrives whether you quit the browser, kill the window or
+ * lose the machine. `beforeunload` does not fire for all of those.
+ *
+ * EventSource reconnects on its own after a drop, which is what makes the
+ * server's grace period work -- a flaky connection comes back inside it and
+ * nothing is stopped.
+ */
+function watchFromThisTab() {
+  try {
+    new EventSource(`${API_BASE}/alive`);
+  } catch {
+    // Older browsers, or a page opened from a file:// URL. Losing this costs
+    // an automatic exit, not a review, so there is nothing to report.
+  }
+}
+
 document.addEventListener('DOMContentLoaded', () => {
+  watchFromThisTab();
+
   document.getElementById('repoPath').addEventListener('keypress', (e) => {
     if (e.key === 'Enter') {
       loadRepo();

package/public/style.css

@@ -221,6 +221,21 @@ button:disabled {
   color: white;
 }
 
+.file-status-deleted {
+  background: #d73a49;
+  color: white;
+}
+
+.file-status-renamed {
+  background: #6f42c1;
+  color: white;
+}
+
+.file-status-binary {
+  background: #6a737d;
+  color: white;
+}
+
 .file-item:hover {
   background: #f3f4f6;
   border-left-color: #0366d6;

package/server.js

@@ -55,6 +55,11 @@ class FileNotFoundError extends Error {
  * @param {boolean} [options.handoff] whether the caller is going to do
  *   something with a submitted review. Reported to the page so it can say
  *   where the review went instead of only offering a download.
+ * @param {() => void} [options.onIdle] called once the last browser tab has
+ *   been gone for `idleGraceMs`, so the process that started the server can
+ *   stop. Omitted means never: a server with no one to tell keeps serving.
+ * @param {number} [options.idleGraceMs] how long to wait after the last tab
+ *   leaves before deciding it is not coming back.
  * @returns {import('express').Express}
  */
 function createApp(options = {}) {
@@ -63,7 +68,9 @@ function createApp(options = {}) {
     sessions = new SessionStore(),
     git: gitFactory = simpleGit,
     onReviewSubmitted = null,
-    handoff = false
+    handoff = false,
+    onIdle = null,
+    idleGraceMs = 5000
   } = options;
 
   const app = express();
@@ -75,6 +82,11 @@ function createApp(options = {}) {
   app.locals.sessions = sessions;
   app.locals.reviewsDir = reviewsDir;
 
+  // How many tabs are currently holding `/api/alive` open, and the timer that
+  // starts when that reaches zero. See the route for why it is a timer.
+  let watching = 0;
+  let idleTimer = null;
+
   /**
    * Look up the session for a request, or answer 400.
    *
@@ -222,6 +234,59 @@ function createApp(options = {}) {
     next();
   }
 
+  /**
+   * Held open for as long as a tab is watching, so the server can tell when
+   * the last one has gone.
+   *
+   * The connection *is* the signal. An open page holds this response open and
+   * closing the page closes it, so there is no heartbeat interval to tune, and
+   * two tabs are two connections rather than one flag that either close
+   * clears. `sameOriginOnly` is here for the same reason it is on the two
+   * below: without it a page on another site could hold this open and keep a
+   * server alive that its owner had finished with.
+   *
+   * Nothing happens at the moment a watcher leaves. A reload closes and
+   * reopens within milliseconds, and a dropped connection reopens when
+   * EventSource retries -- at the instant it happens neither is
+   * distinguishable from someone closing the tab for good. So the last one
+   * leaving starts a timer and the next to arrive cancels it. Guessing wrong
+   * ends a review somebody is in the middle of, which is worth five seconds.
+   *
+   * A server nobody ever opened is not idle. `watching` only falls to zero
+   * after having been above it, so `reviewer` whose browser never launched
+   * keeps serving rather than exiting into an empty terminal.
+   */
+  app.get('/api/alive', sameOriginOnly, (req, res) => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    watching += 1;
+
+    res.set({
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive'
+    });
+    // A comment frame, which EventSource ignores. Sending it now is what
+    // flushes the headers, so the client is connected rather than pending.
+    res.write(': watching\n\n');
+
+    res.on('close', () => {
+      watching -= 1;
+      if (watching > 0 || !onIdle) return;
+
+      idleTimer = setTimeout(() => {
+        idleTimer = null;
+        if (watching === 0) onIdle();
+      }, idleGraceMs);
+      // The listening socket is what holds the process open; this timer
+      // should not be able to on its own, or a closed server would sit
+      // waiting out the grace period before the process could exit.
+      idleTimer.unref();
+    });
+  });
+
   /** List the directories inside one, so a repository can be found by looking. */
   app.get('/api/browse', sameOriginOnly, async (req, res) => {
     try {