bosia 0.8.1 → 0.8.3

package/package.json

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

package/src/cli/dev.ts

@@ -8,5 +8,9 @@ export async function runDev() {
 		stderr: "inherit",
 		cwd: process.cwd(),
 	});
+	// Survive ^C so we keep waiting for the child instead of orphaning it
+	// mid-shutdown. The terminal delivers SIGINT to the whole process group,
+	// so the child already gets the signal — no forwarding needed.
+	for (const sig of ["SIGINT", "SIGTERM"] as const) process.on(sig, () => {});
 	await proc.exited;
 }

package/src/cli/start.ts

@@ -22,5 +22,9 @@ export async function runStart() {
 		},
 	});
 
+	// Survive ^C so we keep waiting for the child instead of orphaning it
+	// mid-drain. The terminal delivers SIGINT to the whole process group,
+	// so the child already gets the signal — no forwarding needed.
+	for (const sig of ["SIGINT", "SIGTERM"] as const) process.on(sig, () => {});
 	await proc.exited;
 }

package/src/cli/sync.ts

@@ -3,6 +3,7 @@ import { generateRoutesFile } from "../core/routeFile.ts";
 import { generateRouteTypes, ensureRootDirs } from "../core/routeTypes.ts";
 import { loadEnv, classifyEnvVars } from "../core/env.ts";
 import { generateEnvModules } from "../core/envCodegen.ts";
+import { findBrandPlaceholders, BRAND_SENTINEL } from "../core/brandGuard.ts";
 
 export async function runSync() {
 	const envMode = process.env.NODE_ENV === "production" ? "production" : "development";
@@ -13,4 +14,14 @@ export async function runSync() {
 	ensureRootDirs();
 	generateEnvModules(classifiedEnv);
 	console.log("✅ Bosia codegen ready (.bosia/routes.ts, types, env modules)");
+
+	const brandHits = findBrandPlaceholders();
+	if (brandHits.length > 0) {
+		console.error(
+			`\n❌ ${BRAND_SENTINEL} placeholder left un-replaced in ${brandHits.length} spot(s):`,
+		);
+		for (const { file, line } of brandHits) console.error(`  • ${file}:${line}`);
+		console.error(`\nReplace ${BRAND_SENTINEL} with the app's name (nav/header/footer).\n`);
+		process.exit(1);
+	}
 }

package/src/core/brandGuard.ts

@@ -0,0 +1,36 @@
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+
+// Registry blocks (navbars, storefront header/footer) ship the brand name as the
+// literal `__BRAND__` sentinel so it's unmistakably a placeholder. This guard fails
+// `bosia sync` (and therefore `bun run check`) if any survive un-replaced in an app —
+// otherwise a fresh scaffold ships someone else's brand in its nav/header/footer.
+export const BRAND_SENTINEL = "__BRAND__";
+
+const SRC_DIR = "./src";
+const TEXT_EXT = /\.(svelte|ts|js|html|md|json)$/;
+
+export function findBrandPlaceholders(srcDir = SRC_DIR): { file: string; line: number }[] {
+	const hits: { file: string; line: number }[] = [];
+	let entries: string[];
+	try {
+		entries = readdirSync(srcDir, { recursive: true }) as string[];
+	} catch {
+		return hits; // no src/ (e.g. non-app cwd) → nothing to guard
+	}
+	for (const rel of entries) {
+		if (!TEXT_EXT.test(rel)) continue;
+		const path = join(srcDir, rel);
+		let contents: string;
+		try {
+			contents = readFileSync(path, "utf-8");
+		} catch {
+			continue; // directory or unreadable
+		}
+		if (!contents.includes(BRAND_SENTINEL)) continue;
+		contents.split("\n").forEach((l, i) => {
+			if (l.includes(BRAND_SENTINEL)) hits.push({ file: path, line: i + 1 });
+		});
+	}
+	return hits;
+}

package/src/core/dev.ts

@@ -17,6 +17,13 @@ const SHELL_ENV_SNAPSHOT: Record<string, string | undefined> = { ...process.env
 
 loadEnv("development");
 
+// Host-managed mode: when a host (rukoku) sets BOSIA_DEV_MANAGED=1 in the unit
+// env, this dev server never self-triggers builds on file change — the host is
+// the single clock and drives one rebuild per turn via POST /__bosia/rebuild
+// (avoids the watcher compiling a half-written file mid-edit). Unset → normal
+// `bosia dev` is byte-for-byte unchanged.
+const MANAGED = process.env.BOSIA_DEV_MANAGED === "1";
+
 function reloadEnv() {
 	for (const k of Object.keys(process.env)) delete process.env[k];
 	for (const [k, v] of Object.entries(SHELL_ENV_SNAPSHOT)) {
@@ -216,25 +223,30 @@ let buildTimer: ReturnType<typeof setTimeout> | null = null;
 let building = false;
 let buildPending = false;
 
-async function buildAndRestart() {
+async function buildAndRestart(): Promise<boolean> {
 	if (building) {
 		buildPending = true;
-		return;
+		// ponytail: coalesced into the in-flight build. Managed mode fires one
+		// rebuild per turn so overlap is rare; report optimistic rather than a
+		// false build failure to the host.
+		return true;
 	}
 	building = true;
 	try {
+		let ok = true;
 		do {
 			buildPending = false;
-			const ok = await runBuild();
+			ok = await runBuild();
 			if (!ok) {
 				console.error("❌ Build failed — fix errors and save again");
-				return;
+				return false;
 			}
 			await startAppServer();
 			// Give the app server a moment to bind its port
 			await Bun.sleep(200);
 			broadcastReload();
 		} while (buildPending);
+		return ok;
 	} finally {
 		building = false;
 	}
@@ -331,6 +343,17 @@ const devServer = Bun.serve({
 			return Response.json({ ok: true, held: false, flushed });
 		}
 
+		// Host-managed rebuild trigger. In managed mode the watcher is off, so the
+		// host (rukoku) POSTs here once per turn after all file writes are done.
+		// Reuses the single-flight building/buildPending guards. The POST awaits the
+		// full build; `{ ok }` is the real build result (compiler errors stream to
+		// stdout/stderr → journald, which the host tails on ok:false). Exists in
+		// both modes; simply unused when the watcher is on.
+		if (url.pathname === "/__bosia/rebuild" && req.method === "POST") {
+			const ok = await buildAndRestart();
+			return Response.json({ ok });
+		}
+
 		// Proxy everything else to the app server. Inject X-Forwarded-Host/Proto so
 		// the app's CSRF origin check (gated behind TRUST_PROXY=true, also set in the
 		// app env above) reconstructs the public-facing origin from the dev proxy
@@ -426,18 +449,27 @@ 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();
-});
+// Managed mode: the host is the single clock, so never self-trigger on file
+// change. Leave both watchers unstarted (null) — boot build + startAppServer
+// still run, so the server builds once and serves; it just waits for the host's
+// POST /__bosia/rebuild instead of watching.
+let srcWatcher: ReturnType<typeof watch> | null = null;
+let mtimePoll: ReturnType<typeof setInterval> | null = null;
+
+if (!MANAGED) {
+	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];
@@ -471,37 +503,39 @@ function walkSrc(out: Map<string, number>): void {
 // Seed the map without firing — first sweep just records existing mtimes.
 walkSrc(mtimes);
 
-const mtimePoll = setInterval(() => {
-	const fresh = new Map<string, number>();
-	walkSrc(fresh);
+if (!MANAGED) {
+	mtimePoll = setInterval(() => {
+		const fresh = new Map<string, number>();
+		walkSrc(fresh);
 
-	let changed: string | null = null;
+		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)) {
+		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?.();
+		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
@@ -517,7 +551,11 @@ const envWatcher = watch(process.cwd(), { recursive: false }, (_event, filename)
 	scheduleBuild();
 });
 
-console.log("👀 Watching src/ for changes...\n");
+console.log(
+	MANAGED
+		? "🛰️  Host-managed mode — builds driven by POST /__bosia/rebuild\n"
+		: "👀 Watching src/ for changes...\n",
+);
 
 // ─── Shutdown ─────────────────────────────────────────────
 // Own SIGINT/SIGTERM so we can cleanly stop the child app server.
@@ -526,16 +564,23 @@ console.log("👀 Watching src/ for changes...\n");
 // a second ^C.
 
 let shuttingDown = false;
+let firstSignalAt = 0;
 async function shutdown() {
-	if (shuttingDown) return; // re-entry from process-group signals or impatient ^C — drain is already running
+	if (shuttingDown) {
+		// One ^C arrives multiple times (process group + `bun run` forwarding
+		// to its child) — only a genuinely later signal is a second ^C.
+		if (Date.now() - firstSignalAt > 200) process.exit(130); // second ^C = force quit
+		return;
+	}
 	shuttingDown = true;
+	firstSignalAt = Date.now();
 	intentionalKill = true;
 
 	if (buildTimer) clearTimeout(buildTimer);
 	if (restartTimer) clearTimeout(restartTimer);
 	if (healthyTimer) clearTimeout(healthyTimer);
-	clearInterval(mtimePoll);
-	srcWatcher.close();
+	if (mtimePoll) clearInterval(mtimePoll);
+	srcWatcher?.close();
 	envWatcher.close();
 	devServer.stop(true); // closes SSE conns → abort listeners clear ping intervals
 
@@ -544,9 +589,8 @@ async function shutdown() {
 		await Promise.race([appProcess.exited, Bun.sleep(2_500)]);
 	}
 
-	// Safety net: if any stray handle still holds the loop, force clean exit.
-	// .unref() so the timer itself doesn't keep the loop alive when drain succeeds.
-	setTimeout(() => process.exit(0), 1_500).unref();
+	// Everything is stopped — exit now rather than waiting for the loop to drain.
+	process.exit(0);
 }
 
 process.on("SIGINT", shutdown);

package/src/core/server.ts

@@ -978,6 +978,7 @@ if (Number.isFinite(MAX_INFLIGHT)) {
 // ─── Graceful Shutdown State ──────────────────────────────
 
 let shuttingDown = false;
+let firstSignalAt = 0;
 let inFlight = 0;
 let drainResolve: (() => void) | null = null;
 
@@ -1097,8 +1098,16 @@ app.listen(PORT, () => {
 });
 
 async function shutdown() {
-	if (shuttingDown) return;
+	if (shuttingDown) {
+		// One ^C arrives multiple times (process group + `bun run` forwarding
+		// to its child) — only a genuinely later signal is a second ^C.
+		if (Date.now() - firstSignalAt > 200) process.exit(130); // second ^C = force quit
+		return;
+	}
 	shuttingDown = true;
+	firstSignalAt = Date.now();
+	// Dev: nothing worth draining — exit instantly so ^C feels immediate.
+	if (isDev) process.exit(0);
 	console.log("⏳ Shutting down — draining in-flight requests...");
 
 	if (inFlight > 0) {