@openparachute/hub 0.6.5-rc.3 → 0.6.5-rc.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openparachute/hub",
-  "version": "0.6.5-rc.3",
+  "version": "0.6.5-rc.4",
   "description": "parachute — the local hub for the Parachute ecosystem (discovery, ports, lifecycle, soon OAuth).",
   "license": "AGPL-3.0",
   "publishConfig": {
@@ -26,6 +26,9 @@
   },
   "scripts": {
     "start": "bun src/cli.ts",
+    "build:depcheck": "[ ! -f packages/depcheck/package.json ] || [ -f packages/depcheck/dist/index.js ] || bun run --cwd packages/depcheck build",
+    "prepare": "bun run build:depcheck",
+    "pretest": "bun run build:depcheck",
     "test": "bun test ./src",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",

package/src/__tests__/hub.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { renderHub, writeHubFile } from "../hub.ts";
@@ -301,4 +301,30 @@ describe("writeHubFile", () => {
       rmSync(dir, { recursive: true, force: true });
     }
   });
+
+  // hub#171: serve regenerates hub.html on EVERY start (the `!existsSync`
+  // guard in commands/serve.ts was dropped), so writeHubFile must be safe to
+  // call when the file already exists and must overwrite stale content with
+  // a fresh render from current code — otherwise an upgrade serves the old
+  // page until an unrelated `parachute expose` re-runs.
+  test("overwrites a pre-existing stale hub.html with a fresh render (hub#171)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pcli-hub-"));
+    try {
+      const path = join(dir, "well-known", "hub.html");
+      // First write creates the well-known dir + a real file; then plant
+      // stale content to simulate an old hub.html left over from a prior code
+      // version after `git pull` + `parachute restart hub`.
+      writeHubFile(path);
+      writeFileSync(path, "<!-- stale pre-upgrade hub.html -->");
+      expect(readFileSync(path, "utf8")).toContain("stale");
+
+      const written = writeHubFile(path);
+      expect(written).toBe(path);
+      const content = readFileSync(path, "utf8");
+      expect(content).not.toContain("stale");
+      expect(content).toBe(renderHub());
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
 });

package/src/__tests__/notes-serve.test.ts

@@ -6,6 +6,7 @@ import {
   normalizeMount,
   notesDistCandidates,
   notesFetch,
+  notesServeOptions,
   resolveNotesDistFrom,
 } from "../notes-serve.ts";
 
@@ -26,6 +27,15 @@ function req(path: string): Request {
   return new Request(`http://127.0.0.1${path}`);
 }
 
+describe("notesServeOptions (hub#399 residual)", () => {
+  test("sets idleTimeout: 255 to outlast edge keep-alive pools, matching hub-server.ts", () => {
+    const opts = notesServeOptions(5173, "/tmp/dist", "/notes");
+    expect(opts.idleTimeout).toBe(255);
+    expect(opts.port).toBe(5173);
+    expect(typeof opts.fetch).toBe("function");
+  });
+});
+
 describe("normalizeMount", () => {
   test("strips trailing slashes", () => {
     expect(normalizeMount("/notes/")).toBe("/notes");

package/src/commands/serve.ts

@@ -337,13 +337,22 @@ export async function serve(opts: ServeOpts = {}): Promise<{
   // hatch for setups that want loopback-only inside a sidecar.
   const hostname = env.PARACHUTE_BIND_HOST || "0.0.0.0";
 
-  // Ensure the well-known dir exists, and seed a static hub.html so `/`
+  // Ensure the well-known dir exists, and (re)write the static hub.html so `/`
   // serves something coherent on a fresh disk (the dynamic path through
   // `hubFetch` takes over once a DB row exists; the disk file is the
   // signed-out fallback).
+  //
+  // Regenerate on EVERY serve start, not just when the file is absent (#171):
+  // hub.html is a served artifact built from current code, and code ships via
+  // `git pull` + `parachute restart hub`. Guarding on `!existsSync` left the
+  // stale post-upgrade file on disk until an unrelated `parachute expose`
+  // re-ran — so operators saw old hub.html after an upgrade. The write is a
+  // cheap, deterministic, atomic (tmp+rename) render of static signed-out
+  // HTML with no expose-state or DB dependency, so it's safe to call every
+  // start.
   if (!existsSync(WELL_KNOWN_DIR)) mkdirSync(WELL_KNOWN_DIR, { recursive: true });
   const hubHtmlPath = join(WELL_KNOWN_DIR, "hub.html");
-  if (!existsSync(hubHtmlPath)) writeHubFile(hubHtmlPath);
+  writeHubFile(hubHtmlPath);
 
   const dbPath = hubDbPath();
   // Self-heal-or-die DB holder (#594). The handle lives behind a mutable

package/src/notes-serve.ts

@@ -176,6 +176,29 @@ export function notesFetch(dist: string, mount: string): (req: Request) => Respo
   };
 }
 
+/**
+ * Build the `Bun.serve` config for the notes static server.
+ *
+ * `idleTimeout: 255` matches hub-server.ts. When this static-serve sits behind
+ * an edge proxy that pools keep-alive connections (Render, Cloudflare, fly
+ * proxy), the edge's idle timeout outlasts Bun's default — the proxy reuses a
+ * connection we just closed and returns a "random" 502. 255s comfortably
+ * exceeds Render's community-observed ~120s edge pool TTL. Closes the hub#399
+ * residual on the second serve entrypoint (the Notes PWA path). Exported so a
+ * test can assert the option is set without booting a server.
+ */
+export function notesServeOptions(
+  port: number,
+  dist: string,
+  mount: string,
+): { port: number; idleTimeout: number; fetch: (req: Request) => Response } {
+  return {
+    port,
+    idleTimeout: 255,
+    fetch: notesFetch(dist, mount),
+  };
+}
+
 if (import.meta.main) {
   const { port, dist: distArg, mount } = parseArgs(process.argv.slice(2));
 
@@ -187,10 +210,7 @@ if (import.meta.main) {
     process.exit(1);
   }
 
-  Bun.serve({
-    port,
-    fetch: notesFetch(dist, mount),
-  });
+  Bun.serve(notesServeOptions(port, dist, mount));
 
   console.log(`notes static-serve listening on :${port} (dist=${dist}, mount=${mount || "/"})`);
 }