npm - bosia - Versions diffs - 0.5.11 → 0.5.12 - Mend

bosia 0.5.11 → 0.5.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/package.json +1 -1
package/src/core/dev-500.ts +127 -0
package/src/core/dev.ts +127 -21
package/src/core/plugins/inspector/overlay.ts +13 -0
package/src/core/renderer.ts +9 -0
package/src/core/server.ts +62 -15

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.5.11",
+	"version": "0.5.12",
 	"type": "module",
 	"description": "A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS. File-based routing inspired by SvelteKit. No Node.js, no Vite, no adapters.",
 	"keywords": [

package/src/core/dev-500.ts ADDED Viewed

@@ -0,0 +1,127 @@
+// Dev-only 500 response with an embedded SSE reload client.
+//
+// Without this, a bare text/JSON 500 leaves the browser stuck on the error
+// page even after the next successful build — the SSE reload event has no
+// listener attached, so the user must manually reload to see the recovered
+// route. Returning HTML with the same SSE subscriber that hydrate.ts uses
+// closes the loop: fix the source → next build → SSE "reload" → location.reload().
+import { escapeHtml, safeJsonForScript } from "./html.ts";
+import { loadPlugins } from "./config.ts";
+import type { BosiaPlugin, RenderContext } from "./types/plugin.ts";
+// Mirrors renderer.ts:pluginRenderFragments but lives here so server.ts can
+// reach it without importing renderer (which would pull in the whole SSR graph
+// just for an error response).
+async function bodyEndFragments(ctx: RenderContext): Promise<string[]> {
+	const plugins = await loadPlugins();
+	const out: string[] = [];
+	for (const p of plugins as BosiaPlugin[]) {
+		const fn = p.render?.bodyEnd;
+		if (!fn) continue;
+		try {
+			const fragment = await fn(ctx);
+			if (fragment) out.push(fragment);
+		} catch {
+			// A broken plugin render must not mask the original error we're
+			// reporting; swallow and continue with the remaining fragments.
+		}
+	}
+	return out;
+}
+// Wraps dev500Response with the inspector overlay (and any other plugin
+// bodyEnd fragments) pre-attached. Use from catch sites that don't already
+// have a RenderContext on hand.
+export async function dev500WithPlugins(
+	opts: Omit<Dev500Options, "bodyEndExtras"> & { url: URL },
+): Promise<Response> {
+	const ctx: RenderContext = {
+		request: opts.request,
+		url: opts.url,
+		route: { pattern: "" },
+		metadata: null,
+	};
+	const bodyEndExtras = await bodyEndFragments(ctx);
+	return dev500Response({ ...opts, bodyEndExtras });
+}
+export interface Dev500Options {
+	request: Request;
+	status?: number;
+	message: string;
+	detail?: string;
+	// Plugin bodyEnd fragments (e.g. the inspector overlay). The renderer
+	// already computes these for the normal error path; pass them through so
+	// the red-badge runtime error reporter stays attached on the fallback page.
+	bodyEndExtras?: string[];
+}
+export function dev500Response({
+	request,
+	status = 500,
+	message,
+	detail,
+	bodyEndExtras,
+}: Dev500Options): Response {
+	// JSON clients (fetch loaders, API consumers) still get JSON — only browser
+	// navigations land on the HTML auto-reload page.
+	const accept = request.headers.get("accept") ?? "";
+	if (!accept.includes("text/html")) {
+		return Response.json({ error: message, ...(detail ? { detail } : {}) }, { status });
+	}
+	const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${status} — ${escapeHtml(message)}</title>
+  <style>
+    html,body{margin:0;padding:0;height:100%;background:#0a0a0a;color:#e5e5e5;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,sans-serif}
+    .wrap{min-height:100%;display:flex;align-items:center;justify-content:center;padding:24px;box-sizing:border-box}
+    .card{max-width:720px;width:100%}
+    .dot{display:inline-block;width:10px;height:10px;background:#dc2626;border-radius:50%;margin-right:8px;vertical-align:middle;animation:p 1.4s ease-in-out infinite}
+    @keyframes p{0%,100%{opacity:1}50%{opacity:.3}}
+    h1{font-size:18px;font-weight:600;margin:0 0 12px}
+    p{margin:0 0 8px;color:#a3a3a3;font-size:13px}
+    pre{margin:12px 0 0;padding:12px;background:#1a1a1a;border:1px solid #262626;border-radius:4px;color:#fafafa;font-family:ui-monospace,monospace;font-size:12px;white-space:pre-wrap;word-break:break-word;max-height:50vh;overflow:auto}
+    .hint{font-size:12px;color:#737373;margin-top:12px}
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <div class="card">
+      <h1><span class="dot"></span>${status} ${escapeHtml(message)}</h1>
+      <p>The server threw while rendering this route. Fix the source and this page will reload automatically when the next build succeeds.</p>
+      ${detail ? `<pre>${escapeHtml(detail)}</pre>` : ""}
+      <p class="hint">Auto-reload listens on <code>/__bosia/sse</code>. Reconnects every 2s if the dev server is restarting.</p>
+    </div>
+  </div>
+  <script>
+    !function r(){
+      try{
+        var e=new EventSource("/__bosia/sse");
+        e.addEventListener("reload",function(){location.reload()});
+        e.onerror=function(){e.close();setTimeout(r,2000)};
+      }catch(_){setTimeout(r,2000)}
+    }();
+  </script>
+  <script type="application/json" id="__bosia-dev-errors__">${safeJsonForScript([
+		{
+			id: `dev500-${Date.now()}`,
+			ts: Date.now(),
+			source: "server",
+			message,
+			stack: detail,
+		},
+  ])}</script>
+  ${bodyEndExtras?.join("\n") ?? ""}
+</body>
+</html>`;
+	return new Response(html, {
+		status,
+		headers: { "Content-Type": "text/html; charset=utf-8" },
+	});
+}

package/src/core/dev.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { spawn, type Subprocess } from "bun";
-import { watch } from "fs";
+import { readdirSync, statSync, watch, type Dirent } from "fs";
 import { join } from "path";
 import { loadEnv, resetDeclaredKeys } from "./env.ts";
 import { BOSIA_NODE_PATH } from "./paths.ts";
@@ -34,9 +34,11 @@ let appProcess: Subprocess | null = null;
 let sseClients = new Set<ReadableStreamDefaultController>();
 let intentionalKill = false;
 let crashCount = 0;
-let lastCrashTime = 0;
-const MAX_RAPID_CRASHES = 3;
-const RAPID_CRASH_WINDOW = 5_000; // 5 seconds
+let restartTimer: ReturnType<typeof setTimeout> | null = null;
+let healthyTimer: ReturnType<typeof setTimeout> | null = null;
+const HEALTHY_AFTER_MS = 5_000;
+// Exponential backoff between successive crash restarts (capped at last value).
+const BACKOFF_SCHEDULE_MS = [500, 1_000, 2_000, 4_000, 5_000];
 // ─── SSE Broadcast ────────────────────────────────────────
@@ -89,6 +91,11 @@ async function startAppServer() {
 		serverEntry = manifest.serverEntry ?? "index.js";
 	} catch {}
+	if (healthyTimer) {
+		clearTimeout(healthyTimer);
+		healthyTimer = null;
+	}
 	appProcess = spawn(["bun", "run", `${DEV_OUT_DIR}/server/${serverEntry}`], {
 		stdout: "inherit",
 		stderr: "inherit",
@@ -109,30 +116,42 @@ async function startAppServer() {
 		},
 	});
-	// Monitor for unexpected crashes
+	// Once the child has stayed alive past HEALTHY_AFTER_MS, treat it as a successful
+	// boot and zero the backoff counter so the next crash starts at 500ms again.
 	const proc = appProcess;
+	healthyTimer = setTimeout(() => {
+		if (proc === appProcess && !intentionalKill) crashCount = 0;
+	}, HEALTHY_AFTER_MS);
+	healthyTimer.unref?.();
+	// Monitor for unexpected crashes. Never give up — backoff and keep trying.
+	// A real source-level crash bug will surface as repeated restart logs; the
+	// moment the user (or AI) fixes it, the next file event triggers a fresh
+	// rebuild and the loop unwinds naturally.
 	proc.exited.then((code) => {
 		if (proc !== appProcess || intentionalKill) return;
 		if (code === 0) return; // clean exit
-		const now = Date.now();
-		if (now - lastCrashTime < RAPID_CRASH_WINDOW) {
-			crashCount++;
-		} else {
-			crashCount = 1;
-		}
-		lastCrashTime = now;
-		if (crashCount >= MAX_RAPID_CRASHES) {
-			console.error(
-				`\n💥 App crashed ${crashCount} times in ${RAPID_CRASH_WINDOW / 1000}s — waiting for file change to restart\n`,
-			);
-			crashCount = 0;
-			return;
+		if (healthyTimer) {
+			clearTimeout(healthyTimer);
+			healthyTimer = null;
 		}
-		console.warn(`\n⚠️  App crashed (exit code ${code}). Restarting...\n`);
-		startAppServer();
+		const delay =
+			BACKOFF_SCHEDULE_MS[Math.min(crashCount, BACKOFF_SCHEDULE_MS.length - 1)] ??
+			BACKOFF_SCHEDULE_MS[BACKOFF_SCHEDULE_MS.length - 1]!;
+		crashCount++;
+		console.warn(
+			`\n⚠️  App crashed (exit code ${code}). Restart attempt #${crashCount} in ${delay}ms...\n`,
+		);
+		if (restartTimer) clearTimeout(restartTimer);
+		restartTimer = setTimeout(() => {
+			restartTimer = null;
+			startAppServer();
+		}, delay);
+		restartTimer.unref?.();
 	});
 }
@@ -276,14 +295,98 @@ function isGenerated(path: string): boolean {
 	return GENERATED.some((g) => path.startsWith(g));
 }
+// ─── mtime Poll Safety Net ────────────────────────────────
+// On macOS, fs.watch misses events from atomic writes (temp file + rename)
+// and frequently delivers `filename === null` for renames. AI agents that edit
+// via rename therefore slip past the fast path. Walk src/ every 5s and call
+// scheduleBuild() on any mtime delta or add/delete. The 300ms build debounce
+// in scheduleBuild() coalesces this with the fs.watch path when both fire.
+//
+// IMPORTANT: fs.watch must update mtimes[file] when it fires — otherwise the
+// next poll sweep sees the new mtime against a stale seed and fires a duplicate
+// scheduleBuild() for an edit that was already handled.
+const SRC_DIR = join(process.cwd(), "src");
+const MTIME_POLL_MS = 5_000;
+const mtimes = new Map<string, number>();
 const srcWatcher = watch(join(process.cwd(), "src"), { recursive: true }, (_event, filename) => {
 	if (!filename) return;
 	const abs = join(process.cwd(), "src", filename);
 	if (isGenerated(abs)) return;
 	console.log(`[watch] changed: ${filename}`);
+	try {
+		mtimes.set(abs, statSync(abs).mtimeMs);
+	} catch {
+		mtimes.delete(abs);
+	}
 	scheduleBuild();
 });
+function walkSrc(out: Map<string, number>): void {
+	const stack: string[] = [SRC_DIR];
+	while (stack.length > 0) {
+		const dir = stack.pop() as string;
+		if (isGenerated(dir)) continue;
+		let entries: Dirent[];
+		try {
+			entries = readdirSync(dir, { withFileTypes: true }) as Dirent[];
+		} catch {
+			continue;
+		}
+		for (const ent of entries) {
+			const name = String(ent.name);
+			const abs = join(dir, name);
+			if (isGenerated(abs)) continue;
+			if (ent.isDirectory()) {
+				stack.push(abs);
+				continue;
+			}
+			if (!ent.isFile()) continue;
+			try {
+				out.set(abs, statSync(abs).mtimeMs);
+			} catch {
+				// file vanished between readdir and stat — ignore
+			}
+		}
+	}
+}
+// Seed the map without firing — first sweep just records existing mtimes.
+walkSrc(mtimes);
+const mtimePoll = setInterval(() => {
+	const fresh = new Map<string, number>();
+	walkSrc(fresh);
+	let changed: string | null = null;
+	for (const [path, ts] of fresh) {
+		const prev = mtimes.get(path);
+		if (prev === undefined || prev !== ts) {
+			changed = path;
+			break;
+		}
+	}
+	if (!changed) {
+		for (const path of mtimes.keys()) {
+			if (!fresh.has(path)) {
+				changed = path;
+				break;
+			}
+		}
+	}
+	if (changed) {
+		const rel = changed.startsWith(SRC_DIR) ? changed.slice(SRC_DIR.length + 1) : changed;
+		console.log(`[poll] changed: ${rel}`);
+		mtimes.clear();
+		for (const [p, t] of fresh) mtimes.set(p, t);
+		scheduleBuild();
+	}
+}, MTIME_POLL_MS);
+mtimePoll.unref?.();
 // ─── .env Watcher ─────────────────────────────────────────
 // Reset to shell-env snapshot and re-run loadEnv so removed/renamed
 // keys don't linger across hot-reloads. The respawn at startAppServer
@@ -313,6 +416,9 @@ async function shutdown() {
 	intentionalKill = true;
 	if (buildTimer) clearTimeout(buildTimer);
+	if (restartTimer) clearTimeout(restartTimer);
+	if (healthyTimer) clearTimeout(healthyTimer);
+	clearInterval(mtimePoll);
 	srcWatcher.close();
 	envWatcher.close();
 	devServer.stop(true); // closes SSE conns → abort listeners clear ping intervals

package/src/core/plugins/inspector/overlay.ts CHANGED Viewed

@@ -267,5 +267,18 @@ if(ERR_ENABLED){
       try{pushError(JSON.parse(ev.data))}catch(_){}
     });
   }catch(_){/* EventSource not available — ignore */}
+  // Allow inline seed scripts on dev error pages (prerender output, the dev-500
+  // fallback, etc.) to surface errors that fired in a process the live SSE can't
+  // reach. Without this the badge stays empty whenever the error happened in a
+  // different process than the one serving /__bosia/errors.
+  window.__BOSIA_PUSH_ERROR__=pushError;
+  try{
+    var n=document.getElementById("__bosia-dev-errors__");
+    if(n){
+      var list=JSON.parse(n.textContent||"[]");
+      for(var i=0;i<list.length;i++)pushError(list[i]);
+    }
+  }catch(_){}
 }
 })();`;

package/src/core/renderer.ts CHANGED Viewed

@@ -19,6 +19,7 @@ import {
 import type { Metadata } from "./hooks.ts";
 import { loadPlugins } from "./config.ts";
 import { reportDevErrorFromCatch } from "./devErrorReport.ts";
+import { dev500Response } from "./dev-500.ts";
 import type { BosiaPlugin, RenderContext } from "./types/plugin.ts";
 import { getAppHtmlSegments } from "./appHtml.ts";
 import type { AppHtmlSegments } from "./appHtml.ts";
@@ -952,6 +953,14 @@ export async function renderErrorPage(
 			if (isDev) reportDevErrorFromCatch(err);
 		}
 	}
+	// Dev: render an HTML 500 page that subscribes to /__bosia/sse so the browser
+	// auto-reloads the moment the next build succeeds. Without this the user stares
+	// at "Internal Server Error" forever even after fixing the source. Pass the
+	// already-computed bodyEndExtras so the inspector overlay (red error badge,
+	// pre-seeded buffered errors) stays attached even on this bare-fallback path.
+	if (isDev) {
+		return dev500Response({ request: req, status, message, bodyEndExtras });
+	}
 	return new Response(message, {
 		status,
 		headers: { "Content-Type": "text/plain; charset=utf-8" },

package/src/core/server.ts CHANGED Viewed

@@ -22,6 +22,7 @@ import { applyCorsVary, getCorsHeaders, handlePreflight } from "./cors.ts";
 import type { CorsConfig } from "./cors.ts";
 import { buildCspHeader, CSP_DIRECTIVES_TEMPLATE, CSP_ENABLED, generateNonce } from "./csp.ts";
 import { isDev, compress, isStaticPath } from "./html.ts";
+import { dev500WithPlugins } from "./dev-500.ts";
 import { OUT_DIR } from "./paths.ts";
 import { dedup, dedupKey } from "./dedup.ts";
 import { reportDevErrorFromCatch } from "./devErrorReport.ts";
@@ -282,6 +283,15 @@ async function resolve(event: RequestEvent): Promise<Response> {
 			if (isDev) console.error("Data endpoint error:", err);
 			else console.error("Data endpoint error:", (err as Error).message ?? err);
 			if (isDev) reportDevErrorFromCatch(err);
+			if (isDev) {
+				const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
+				return dev500WithPlugins({
+					request,
+					url,
+					message: "Internal Server Error",
+					detail,
+				});
+			}
 			return Response.json({ error: "Internal Server Error" }, { status: 500 });
 		}
 	}
@@ -324,21 +334,30 @@ async function resolve(event: RequestEvent): Promise<Response> {
 		return new Response("Not Found", { status: 404 });
 	}
-	// Prerendered pages — serve static HTML built at build time
-	// Try both `<path>/index.html` (always/ignore mode) and `<path>.html` (never mode)
-	const prerenderCandidates =
-		path === "/" ? ["index.html"] : [`${path}/index.html`, `${path.replace(/\/$/, "")}.html`];
-	for (const candidate of prerenderCandidates) {
-		const prerenderPath = safePath(`${OUT_DIR}/prerendered`, candidate);
-		if (!prerenderPath) continue;
-		const prerenderFile = Bun.file(prerenderPath);
-		if (await prerenderFile.exists()) {
-			return new Response(prerenderFile, {
-				headers: {
-					"Content-Type": "text/html; charset=utf-8",
-					"Cache-Control": "public, max-age=3600",
-				},
-			});
+	// Prerendered pages — serve static HTML built at build time.
+	// SKIP in dev: prerender runs with NODE_ENV=production, which disables the
+	// inspector plugin and the dev-only error pipeline. Serving its output back
+	// in dev would mask errors (the badge stays empty, the SSE reload script
+	// isn't injected, and the page can't auto-recover when the source is fixed).
+	// Live SSR every request in dev so /about behaves like every other route.
+	if (!isDev) {
+		// Try both `<path>/index.html` (always/ignore mode) and `<path>.html` (never mode)
+		const prerenderCandidates =
+			path === "/"
+				? ["index.html"]
+				: [`${path}/index.html`, `${path.replace(/\/$/, "")}.html`];
+		for (const candidate of prerenderCandidates) {
+			const prerenderPath = safePath(`${OUT_DIR}/prerendered`, candidate);
+			if (!prerenderPath) continue;
+			const prerenderFile = Bun.file(prerenderPath);
+			if (await prerenderFile.exists()) {
+				return new Response(prerenderFile, {
+					headers: {
+						"Content-Type": "text/html; charset=utf-8",
+						"Cache-Control": "public, max-age=3600",
+					},
+				});
+			}
 		}
 	}
@@ -365,6 +384,15 @@ async function resolve(event: RequestEvent): Promise<Response> {
 			if (isDev) console.error("API route error:", err);
 			else console.error("API route error:", (err as Error).message ?? err);
 			if (isDev) reportDevErrorFromCatch(err);
+			if (isDev) {
+				const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
+				return dev500WithPlugins({
+					request,
+					url,
+					message: "Internal Server Error",
+					detail,
+				});
+			}
 			return Response.json({ error: "Internal Server Error" }, { status: 500 });
 		}
 	}
@@ -545,6 +573,15 @@ async function resolve(event: RequestEvent): Promise<Response> {
 						{ status: 500 },
 					);
 				}
+				if (isDev) {
+					const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
+					return dev500WithPlugins({
+						request,
+						url,
+						message: "Internal Server Error",
+						detail,
+					});
+				}
 				return Response.json({ error: "Internal Server Error" }, { status: 500 });
 			}
 		}
@@ -644,6 +681,16 @@ async function handleRequest(request: Request, url: URL): Promise<Response> {
 		if (isDev) console.error("Unhandled request error:", err);
 		else console.error("Unhandled request error:", (err as Error).message ?? err);
 		if (isDev) reportDevErrorFromCatch(err);
+		if (isDev) {
+			const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
+			return dev500WithPlugins({
+				request,
+				url,
+				status: 500,
+				message: "Internal Server Error",
+				detail,
+			});
+		}
 		return Response.json({ error: "Internal Server Error" }, { status: 500 });
 	} finally {
 		inFlight--;