@oar-sh/oar 0.9.9 → 0.9.11

package/server/services/preview-health-probe.mjs

@@ -2,7 +2,7 @@
 
 import net from 'net';
 
-// Liveness for preview cards. Previews never auto-close, so the card has to say
+// Liveness for preview cards. Previews never expire, so the card has to say
 // whether the dev server behind it is still up — a TCP connect is enough and,
 // unlike an HTTP request, leaves nothing in the app's request log.
 
@@ -55,6 +55,10 @@ export function createPreviewHealthProbe({
     // A slow sweep must not overlap itself; with the registry capped at 8
     // previews and a 250ms connect budget, one pass is bounded at ~2s anyway.
     if (sweeping) return;
+    // Store writes that failed (a locked database) are retried on this beat,
+    // so the table catches up with memory without a timer of its own, and
+    // rows a restore could not judge get their check again.
+    try { registry.maintain?.(); } catch {}
     const previews = registry.list().filter((entry) => entry.mode !== 'static');
     if (previews.length === 0) return;
     sweeping = true;
@@ -70,6 +74,9 @@ export function createPreviewHealthProbe({
     timer = setIntervalImpl(() => { sweep().catch(() => {}); }, intervalMs);
     // An idle relay should not be held awake by a probe that has nothing to do.
     if (typeof timer?.unref === 'function') timer.unref();
+    // One pass right away: port previews restored at boot start without a
+    // health state, and their cards should not wait a full interval for one.
+    sweep().catch(() => {});
   }
 
   function stop() {

package/server/services/preview-proxy-server.mjs

@@ -2,7 +2,7 @@
 
 import http from 'http';
 
-import { parsePreviewPath } from './preview-registry-service.mjs';
+import { parsePreviewPath, previewLogId } from './preview-registry-service.mjs';
 import { serveStaticPreview } from './preview-static-handler.mjs';
 
 // The preview listener. A bare http.Server on its own loopback port whose
@@ -270,12 +270,16 @@ export function createPreviewProxyServer({
     socket.once('error', forget);
   }
 
-  function logHit(entry, req) {
+  // The token is the capability and the request URL carries it, so the line
+  // names the preview by a hash and logs only the upstream path, without query.
+  function logHit(entry, req, upstreamPath) {
     const now = Date.now();
     const last = lastHitLogAt.get(entry.token) || 0;
     if (now - last < 60_000) return;
     lastHitLogAt.set(entry.token, now);
-    logger?.log?.(`[preview] ${entry.token.slice(0, 8)} → :${entry.targetPort} ${req.method} ${req.url} from ${clientIp(req)}`);
+    const target = entry.mode === 'static' ? 'static' : `:${entry.targetPort}`;
+    const pathOnly = String(upstreamPath || '/').split('?')[0];
+    logger?.log?.(`[preview] ${previewLogId(entry.token)} → ${target} ${req.method} ${pathOnly} from ${clientIp(req)}`);
   }
 
   function resolveRequest(req) {
@@ -309,7 +313,7 @@ export function createPreviewProxyServer({
 
     const { entry, upstreamPath } = resolved;
     registry.recordHit(entry.token);
-    logHit(entry, req);
+    logHit(entry, req, upstreamPath);
 
     // Static previews are answered in-process — no upstream, no forwarding.
     if (entry.mode === 'static') {
@@ -399,13 +403,33 @@ export function createPreviewProxyServer({
 
   // WebSocket upgrades (Vite HMR, an app's own socket) ride the same prefix.
   function handleUpgrade(req, socket, head) {
+    // Node removes its own error listener from a socket the moment it emits
+    // 'upgrade', and the upstream socket handed to 'upgrade' comes bare too. A
+    // browser that drops the connection while the dev server is still
+    // answering would otherwise raise an uncaught ECONNRESET and end the
+    // whole relay. Whatever fails on either side takes both down.
+    let upstreamReq = null;
+    let upstreamSocket = null;
+    const teardown = () => {
+      try { socket.destroy(); } catch {}
+      try { upstreamSocket?.destroy(); } catch {}
+      try { upstreamReq?.destroy(); } catch {}
+    };
+    socket.on('error', teardown);
+    // A client that leaves before the dev server answers abandons the
+    // handshake. Once both sides are piped, an orderly close travels through
+    // the pipes, so the pending writes still reach the other side.
+    socket.once('close', teardown);
+    const reply = (text) => {
+      if (socket.destroyed) return;
+      try { socket.write(text); } catch {}
+    };
+
     const resolved = resolveRequest(req);
     // Static previews have nothing to upgrade to; refuse like an unknown token.
     if (resolved.kind !== 'proxy' || resolved.entry?.mode === 'static') {
-      try {
-        socket.write('HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n');
-      } catch {}
-      try { socket.destroy(); } catch {}
+      reply('HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n');
+      teardown();
       return;
     }
 
@@ -426,7 +450,7 @@ export function createPreviewProxyServer({
     headers.connection = 'Upgrade';
     headers.upgrade = String(req.headers.upgrade || 'websocket');
 
-    const upstreamReq = httpImpl.request({
+    upstreamReq = httpImpl.request({
       host: entry.targetHost,
       port: entry.targetPort,
       method: req.method,
@@ -436,25 +460,26 @@ export function createPreviewProxyServer({
     });
     guardConnectTimeout(upstreamReq, connectTimeoutMs, () => {});
 
-    upstreamReq.on('upgrade', (upstreamRes, upstreamSocket, upstreamHead) => {
+    upstreamReq.on('upgrade', (upstreamRes, answeredSocket, upstreamHead) => {
+      upstreamSocket = answeredSocket;
+      upstreamSocket.on('error', teardown);
+      // The client left while the dev server was answering.
+      if (socket.destroyed) {
+        teardown();
+        return;
+      }
       const lines = [`HTTP/1.1 ${upstreamRes.statusCode} ${upstreamRes.statusMessage}`];
       for (const [name, value] of Object.entries(upstreamRes.headers)) {
         for (const entryValue of Array.isArray(value) ? value : [value]) {
           lines.push(`${name}: ${entryValue}`);
         }
       }
-      try {
-        socket.write(`${lines.join('\r\n')}\r\n\r\n`);
-      } catch {
-        try { upstreamSocket.destroy(); } catch {}
-        return;
-      }
-      if (upstreamHead?.length) socket.write(upstreamHead);
+      reply(`${lines.join('\r\n')}\r\n\r\n`);
+      if (upstreamHead?.length) reply(upstreamHead);
       if (head?.length) upstreamSocket.write(head);
+      socket.removeListener('close', teardown);
       trackUpgradedSocket(socket);
       trackUpgradedSocket(upstreamSocket);
-      upstreamSocket.on('error', () => { try { socket.destroy(); } catch {} });
-      socket.on('error', () => { try { upstreamSocket.destroy(); } catch {} });
       upstreamSocket.pipe(socket);
       socket.pipe(upstreamSocket);
     });
@@ -462,18 +487,15 @@ export function createPreviewProxyServer({
     // A dev server that answers an upgrade with a plain response (404 on an
     // unknown HMR path) must not leave the client hanging.
     upstreamReq.on('response', (upstreamRes) => {
-      try {
-        socket.write(`HTTP/1.1 ${upstreamRes.statusCode} ${upstreamRes.statusMessage}\r\nConnection: close\r\n\r\n`);
-      } catch {}
+      reply(`HTTP/1.1 ${upstreamRes.statusCode} ${upstreamRes.statusMessage}\r\nConnection: close\r\n\r\n`);
+      upstreamRes.on('error', () => {});
       upstreamRes.resume();
-      try { socket.destroy(); } catch {}
+      teardown();
     });
 
     upstreamReq.on('error', () => {
-      try {
-        socket.write('HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n');
-      } catch {}
-      try { socket.destroy(); } catch {}
+      reply('HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n');
+      teardown();
     });
 
     upstreamReq.end();