@sigil-dev/grimoire 0.8.4 → 0.8.6

package/package.json

@@ -3,7 +3,7 @@
   "module": "index.ts",
   "type": "module",
   "private": false,
-  "version": "0.8.4",
+  "version": "0.8.6",
   "exports": {
     ".": "./index.ts",
     "./server": "./server.ts",
@@ -33,13 +33,13 @@
     "vite": "^8.0.16"
   },
   "peerDependencies": {
-    "@sigil-dev/compiler": "0.8.4",
-    "@sigil-dev/runtime": "0.8.4",
+    "@sigil-dev/compiler": "0.8.6",
+    "@sigil-dev/runtime": "0.8.6",
     "typescript": "^5"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@sigil-dev/compiler": "0.8.4",
-    "@sigil-dev/runtime": "0.8.4"
+    "@sigil-dev/compiler": "0.8.6",
+    "@sigil-dev/runtime": "0.8.6"
   }
 }

package/server.ts

@@ -12,3 +12,4 @@ export {
 } from "./src/server/plugins";
 export type { TypegenConfig } from "./src/typegen";
 export { generateTypes } from "./src/typegen";
+export {createWaiter, listenForKeys, stopListening} from "./src/server/interactive.ts"

package/src/rendering/index.ts

@@ -36,14 +36,16 @@ export async function renderRoute(
 	locals: Record<string, any> = {},
 	plugins: GrimoirePlugin[] = [],
 	cspNonce?: string,
-	dev?: boolean,
+    dev?: boolean,
+	patchedFetch
 ): Promise<Response> {
 	return runWithContext(async () => {
 		const context: LoadContext = {
 			request: req,
 			params: matched.params,
 			url: new URL(req.url),
-			locals,
+            locals,
+			fetch: patchedFetch ?? globalThis.fetch
 		};
 
 		initHead(cspNonce);

package/src/routing/transform-routes.ts

@@ -76,8 +76,8 @@ export async function transformRoutes(
 					plugins: ["typescript", "jsx"], // no isTSX
 				},
 				plugins: [
-                    [sigilPlugin, { hash, mode }],
-                    //@ts-expect-error it fills what it needs
+					[sigilPlugin, { hash, mode }],
+					//@ts-expect-error it fills what it needs
 					rewriteRelativeImports(route.filePath),
 				],
 				filename: route.filePath,

package/src/server/coordinator.ts

@@ -3,303 +3,270 @@ import { type Subprocess, spawn } from "bun";
 import { matchRoute } from "../routing/router";
 import { type RouteFile, type RouteTree, scanRoutes } from "../routing/scanner";
 import type {
-	CoordinatorContext,
-	GrimoireConfig,
-	GrimoirePlugin,
-	WorkerDescriptor,
-	WorkerMode,
+    CoordinatorContext,
+    GrimoireConfig,
+    GrimoirePlugin,
+    WorkerDescriptor,
+    WorkerMode,
 } from "../types";
 import { buildProject } from "./build";
 import {
-	runHook,
-	runRouteRequest,
-	runSerializeLocals,
-	runWorkerSpawn,
+    runHook,
+    runRouteRequest,
+    runSerializeLocals,
+    runWorkerSpawn,
 } from "./plugins";
+import { log } from "../logger/instance";
+
+const logger = log.scope("loom")
 
 async function waitForWorkers(
-	workers: LiveWorker[],
-	timeoutMs = 10_000,
+    workers: LiveWorker[],
+    timeoutMs = 10_000,
 ): Promise<void> {
-	const ready = new Set<number>();
-	const start = Date.now();
-
-	while (ready.size < workers.length) {
-		if (Date.now() - start > timeoutMs) {
-			const pending = workers
-				.filter((w) => !ready.has(w.descriptor.globalIndex))
-				.map(
-					(w) =>
-						w.descriptor.name ?? `${w.descriptor.mode}-${w.descriptor.index}`,
-				)
-				.join(", ");
-			throw new Error(
-				`Grimoire: workers timed out waiting to become ready: ${pending}`,
-			);
-		}
-		for (const w of workers) {
-			if (ready.has(w.descriptor.globalIndex)) continue;
-			if (w.descriptor.pid != null) {
-				ready.add(w.descriptor.globalIndex);
-			}
-		}
-		await Bun.sleep(50);
-	}
+    const ready = new Set<number>();
+    const start = Date.now();
+    while (ready.size < workers.length) {
+        if (Date.now() - start > timeoutMs) {
+            const pending = workers
+                .filter((w) => !ready.has(w.descriptor.globalIndex))
+                .map((w) => w.descriptor.name ?? `${w.descriptor.mode}-${w.descriptor.index}`)
+                .join(", ");
+            throw new Error(`Grimoire: workers timed out: ${pending}`);
+        }
+        for (const w of workers) {
+            if (!ready.has(w.descriptor.globalIndex) && w.descriptor.pid != null) {
+                ready.add(w.descriptor.globalIndex);
+            }
+        }
+        await Bun.sleep(50);
+    }
 }
 
 function roundRobin(workers: WorkerDescriptor[]): WorkerDescriptor {
-	const idx = roundRobinCounter++ % workers.length;
-	return workers[idx];
+    const idx = roundRobinCounter++ % workers.length;
+    return workers[idx];
 }
 let roundRobinCounter = 0;
 
-function consistentHash(
-	req: Request,
-	workers: WorkerDescriptor[],
-): WorkerDescriptor {
-	const key = req.headers.get("cookie") ?? req.url;
-	let hash = 0;
-	for (let i = 0; i < key.length; i++) {
-		hash = (hash * 31 + key.charCodeAt(i)) >>> 0;
-	}
-	return workers[hash % workers.length];
+function consistentHash(req: Request, workers: WorkerDescriptor[]): WorkerDescriptor {
+    const key = req.headers.get("cookie") ?? req.url;
+    let hash = 0;
+    for (let i = 0; i < key.length; i++) hash = (hash * 31 + key.charCodeAt(i)) >>> 0;
+    return workers[hash % workers.length];
 }
 
-function defaultRoute(
-	req: Request,
-	workers: WorkerDescriptor[],
-	tree: RouteTree,
-): WorkerDescriptor {
-	const isWs = req.headers.get("upgrade")?.toLowerCase() === "websocket";
-
-	if (isWs) {
-		const wsWorkers = workers.filter(
-			(w) => w.mode === "ws" || w.mode === "full",
-		);
-		if (wsWorkers.length) return consistentHash(req, wsWorkers);
-	}
-
-	const url = new URL(req.url);
-	const matched = matchRoute(tree, url);
-
-	if (matched?.route.type === "server") {
-		const apiWorkers = workers.filter(
-			(w) => w.mode === "api" || w.mode === "full",
-		);
-		if (apiWorkers.length) return roundRobin(apiWorkers);
-	}
-
-	const frontendWorkers = workers.filter(
-		(w) => w.mode === "frontend" || w.mode === "full",
-	);
-	if (frontendWorkers.length) return roundRobin(frontendWorkers);
-
-	// fallback — should not happen if scale spec is valid
-	return workers[0];
+function defaultRoute(req: Request, workers: WorkerDescriptor[], tree: RouteTree): WorkerDescriptor {
+    const isWs = req.headers.get("upgrade")?.toLowerCase() === "websocket";
+    if (isWs) {
+        const ws = workers.filter((w) => w.mode === "ws" || w.mode === "full");
+        if (ws.length) return consistentHash(req, ws);
+    }
+    const url = new URL(req.url);
+    const matched = matchRoute(tree, url);
+    if (matched?.route.type === "server") {
+        const api = workers.filter((w) => w.mode === "api" || w.mode === "full");
+        if (api.length) return roundRobin(api);
+    }
+    const frontend = workers.filter((w) => w.mode === "frontend" || w.mode === "full");
+    if (frontend.length) return roundRobin(frontend);
+    return workers[0];
 }
 
 export interface ScaleSpec {
-	api?: number;
-	frontend?: number;
-	ws?: number;
-	[mode: string]: number | undefined;
+    api?: number;
+    frontend?: number;
+    ws?: number;
+    [mode: string]: number | undefined;
 }
 
 export interface CoordinatorOptions {
-	config: GrimoireConfig;
-	plugins: GrimoirePlugin[];
-	scale: ScaleSpec;
-	noBuild: boolean;
+    config:   GrimoireConfig;
+    plugins:  GrimoirePlugin[];
+    scale:    ScaleSpec;
+    noBuild:  boolean;
 }
 
 interface LiveWorker {
-	descriptor: WorkerDescriptor;
-	process: Subprocess;
-	port: number;
+    descriptor: WorkerDescriptor;
+    process:    Subprocess;
+    port:       number;
+    env: Record<string, string>;
+    intentional:   boolean; // ← add
 }
 
 export async function startCoordinator(options: CoordinatorOptions) {
-	const { config, plugins, scale, noBuild } = options;
-	const { port = 3000, host = "localhost", routes = "src/routes" } = config;
-	let stopping = false;
-
-	// 1. build if needed
-	if (!noBuild) {
-		const { result } = await buildProject(config, plugins);
-		if (!result.success) throw new Error("Grimoire: build failed");
-	}
-
-	// 2. generate ephemeral secret
-	const secret = crypto.randomUUID() + crypto.randomUUID(); // 72 hex chars
-
-	// 3. scan routes once — coordinator owns the route tree
-	const routesDir = /* resolve */ routes;
-	const tree = await scanRoutes(routesDir, process.cwd());
-
-	// 4. derive route slices per mode
-	const slices: Record<string, RouteFile[]> = {
-		api: tree.routes.filter((r) => r.type === "server"),
-		ws: tree.routes.filter((r) => r.type === "server"),
-		frontend: tree.routes.filter(
-			(r) => r.type === "page" || r.type === "simple",
-		),
-		full: [...tree.routes],
-	};
-
-	// 5. spawn workers
-	const liveWorkers: LiveWorker[] = [];
-	let globalIndex = 0;
-	let nextPort = port + 1;
-
-	for (const [mode, count = 0] of Object.entries(scale)) {
-		for (let i = 0; i < count; i++) {
-			const workerPort = nextPort++;
-			const descriptor: WorkerDescriptor = {
-				mode: mode as WorkerMode,
-				index: i + 1,
-				globalIndex: globalIndex++,
-				internalUrl: `http://127.0.0.1:${workerPort}`,
-				routes: slices[mode] ?? slices.full,
-			};
-
-			// let plugins inject env and name
-			const workerEnv = await runWorkerSpawn(plugins, descriptor);
-			const workerEntry = join(import.meta.dir, "./worker.ts");
-			if (workerEnv.name) descriptor.name = workerEnv.name;
-
-			// Inject env vars prefixed with PUBLIC_ so they're available to client bundles
-			const publicEnvVars: Record<string, string> = {};
-			for (const [key, value] of Object.entries(process.env)) {
-				if (key.startsWith("PUBLIC_") && value !== undefined) {
-					publicEnvVars[key] = value;
-				}
-			}
-
-			const proc = spawn(["bun", "run", workerEntry], {
-				env: {
-					...process.env,
-					...workerEnv.env,
-					...publicEnvVars,
-					GRIMOIRE_MODE: mode,
-					GRIMOIRE_WORKER_INDEX: String(i),
-					GRIMOIRE_WORKER_PORT: String(workerPort),
-					GRIMOIRE_INTERNAL_SECRET: secret,
-					GRIMOIRE_WORKER_NAME: descriptor.name ?? `${mode}-${i}`,
-				},
-				ipc(message) {
-					// worker sends { ready: true } when Bun.serve is up
-					if (message?.ready) {
-						descriptor.pid = proc.pid;
-						runHook(plugins, "onWorkerReady", descriptor);
-					}
-				},
-				onExit(_proc, exitCode) {
-					const intentional = stopping;
-					runHook(
-						plugins,
-						"onWorkerDeath",
-						descriptor,
-						intentional ? "intentional" : "crash",
-					);
-					if (!intentional) {
-						console.error(
-							`[grimoire] worker ${descriptor.name ?? `${descriptor.mode}-${descriptor.index}`} crashed (exit ${exitCode}), respawning...`,
-						);
-						// respawn: same descriptor, same port
-						// (simplified — plugin-scale can override this behavior)
-					}
-				},
-			});
-
-			liveWorkers.push({ descriptor, process: proc, port: workerPort });
-		}
-	}
-
-	// 6. wait for all workers ready (with timeout)
-	// workers send IPC { ready: true } — coordinator waits up to 10s
-	await waitForWorkers(liveWorkers);
-
-	// 7. fire onCoordinatorStart
-	const ctx: CoordinatorContext = {
-		workers: liveWorkers.map((w) => w.descriptor),
-		port,
-		secret,
-		routes: tree,
-	};
-	await runHook(plugins, "onCoordinatorStart", ctx);
-
-	// 8. start coordinator Bun.serve
-
-	const server = Bun.serve({
-		port,
-		hostname: host,
-		fetch: async (req) => {
-			// run hooks.server.ts to populate locals
-			const locals: App.Locals = {};
-			// ... same handle() chain as createServer but resolve() just
-			// forwards instead of rendering
-
-			// pick worker
-			const descriptors = liveWorkers.map((w) => w.descriptor);
-			const chosen =
-				(await runRouteRequest(plugins, req, descriptors, tree)) ??
-				defaultRoute(req, descriptors, tree);
-
-			// serialize locals
-			const serialized =
-				(await runSerializeLocals(plugins, locals)) ??
-				defaultSerialize(locals, secret);
-
-			// forward
-			return fetch(chosen.internalUrl + new URL(req.url).pathname, {
-				method: req.method,
-				headers: {
-					//@ts-expect-error shut Up
-					...Object.fromEntries(req.headers),
-					"X-Grimoire-Locals": serialized,
-					"X-Grimoire-Internal": secret,
-				},
-				body: req.body,
-			});
-		},
-	});
-
-	// 9. shutdown
-	const handleShutdown = async () => {
-		if (stopping) return;
-		stopping = true;
-		await runHook(plugins, "onStop", "shutdown");
-		for (const w of liveWorkers) w.process.kill();
-		server.stop();
-		process.exit(0);
-	};
-	process.on("SIGINT", handleShutdown);
-	process.on("SIGTERM", handleShutdown);
-
-	return {
-		server,
-		workers: liveWorkers.map((w) => ({
-			name: w.descriptor.name,
-			mode: w.descriptor.mode,
-			port: w.port,
-			index: w.descriptor.index,
-		})),
-	};
+    const { config, plugins, scale, noBuild } = options;
+    const { port = 3000, host = "localhost", routes = "src/routes" } = config;
+    let stopping = false;
+
+    const workerEntry = join(import.meta.dir, "./worker.ts");
+
+    // ── inner helpers (close over plugins/stopping/workerEntry) ──
+
+    function spawnWorker(lw: LiveWorker): void {
+        const proc = spawn(["bun", "run", workerEntry], {
+            env: lw.env,
+            ipc(message) {
+                if (message?.ready) {
+                    lw.descriptor.pid = proc.pid;
+                    runHook(plugins, "onWorkerReady", lw.descriptor);
+                }
+            },
+            onExit(_, exitCode) {
+                if (lw.intentional) {
+                    lw.intentional = false;
+                    return;
+                }
+                runHook(plugins, "onWorkerDeath", lw.descriptor, stopping ? "intentional" : "crash");
+                if (!stopping) {
+                    logger.error(`worker ${lw.descriptor.name ?? `${lw.descriptor.mode}-${lw.descriptor.index}`} crashed (exit ${exitCode}), respawning...`);
+                }
+            },
+        });
+        lw.process = proc;
+    }
+
+    async function respawnWorker(lw: LiveWorker): Promise<void> {
+        lw.intentional = true;
+        lw.process.kill();
+        lw.descriptor.pid = undefined;
+        spawnWorker(lw);
+        await waitForWorkers([lw]);
+    }
+
+    // 1. build
+    if (!noBuild) {
+        const { result } = await buildProject(config, plugins);
+        if (!result.success) throw new Error("Grimoire: build failed");
+    }
+
+    // 2. ephemeral secret
+    const secret = crypto.randomUUID() + crypto.randomUUID();
+
+    // 3. scan routes
+    const tree = await scanRoutes(routes, process.cwd());
+
+    // 4. route slices
+    const slices: Record<string, RouteFile[]> = {
+        api:      tree.routes.filter((r) => r.type === "server"),
+        ws:       tree.routes.filter((r) => r.type === "server"),
+        frontend: tree.routes.filter((r) => r.type === "page" || r.type === "simple"),
+        full:     [...tree.routes],
+    };
+
+    // 5. spawn workers
+    const liveWorkers: LiveWorker[] = [];
+    let globalIndex = 0;
+    let nextPort = port + 1;
+
+    for (const [mode, count = 0] of Object.entries(scale)) {
+        for (let i = 0; i < count; i++) {
+            const workerPort = nextPort++;
+            const descriptor: WorkerDescriptor = {
+                mode:        mode as WorkerMode,
+                index:       i + 1,
+                globalIndex: globalIndex++,
+                internalUrl: `http://127.0.0.1:${workerPort}`,
+                routes:      slices[mode] ?? slices.full,
+            };
+
+            const publicEnvVars: Record<string, string> = {};
+            for (const [k, v] of Object.entries(process.env)) {
+                if (k.startsWith("PUBLIC_") && v !== undefined) publicEnvVars[k] = v;
+            }
+
+            const workerEnv = await runWorkerSpawn(plugins, descriptor);
+            if (workerEnv.name) descriptor.name = workerEnv.name;
+
+            const env = {
+                ...process.env,
+                ...workerEnv.env,
+                ...publicEnvVars,
+                GRIMOIRE_MODE:            mode,
+                GRIMOIRE_WORKER_INDEX:    String(i),
+                GRIMOIRE_WORKER_PORT:     String(workerPort),
+                GRIMOIRE_INTERNAL_SECRET: secret,
+                GRIMOIRE_WORKER_NAME:     descriptor.name ?? `${mode}-${i}`,
+            } as Record<string, string>;
+
+            const lw: LiveWorker = { descriptor, process: null as any, port: workerPort, env, intentional: false };
+            spawnWorker(lw);
+            liveWorkers.push(lw);
+        }
+    }
+
+    // 6. wait for ready
+    await waitForWorkers(liveWorkers);
+
+    // 7. onCoordinatorStart
+    const ctx: CoordinatorContext = {
+        workers: liveWorkers.map((w) => w.descriptor),
+        port,
+        secret,
+        routes: tree,
+    };
+    await runHook(plugins, "onCoordinatorStart", ctx);
+
+    // 8. coordinator server
+    const server = Bun.serve({
+        port,
+        hostname: host,
+        fetch: async (req) => {
+            const locals: App.Locals = {};
+            const descriptors = liveWorkers.map((w) => w.descriptor);
+            const chosen =
+                (await runRouteRequest(plugins, req, descriptors, tree)) ??
+                defaultRoute(req, descriptors, tree);
+            const serialized =
+                (await runSerializeLocals(plugins, locals)) ??
+                defaultSerialize(locals, secret);
+            return fetch(chosen.internalUrl + new URL(req.url).pathname + new URL(req.url).search, {
+                method:  req.method,
+                headers: {
+                    //@ts-expect-error shut up
+                    ...Object.fromEntries(req.headers),
+                    "X-Grimoire-Locals":    serialized,
+                    "X-Grimoire-Internal":  secret,
+                },
+                body: req.body,
+            });
+        },
+    });
+
+    // 9. expose stop + restartAll — CLI owns process lifetime
+    const stop = async () => {
+        if (stopping) return;
+        stopping = true;
+        await runHook(plugins, "onStop", "shutdown");
+        for (const w of liveWorkers) w.process.kill();
+        server.stop();
+    };
+
+    const restartAll = () => Promise.all(liveWorkers.map((w) => respawnWorker(w)));
+
+    return {
+        server,
+        stop,
+        restartAll,
+        workers: liveWorkers.map((w) => ({
+            name:  w.descriptor.name,
+            mode:  w.descriptor.mode,
+            port:  w.port,
+            index: w.descriptor.index,
+        })),
+    };
 }
 
 function defaultSerialize(locals: App.Locals, secret: string): string {
-	const payload = JSON.stringify(locals);
-	const sig = new Bun.CryptoHasher("sha256")
-		.update(secret + payload)
-		.digest("hex");
-	return Buffer.from(JSON.stringify({ payload, sig })).toString("base64");
+    const payload = JSON.stringify(locals);
+    const sig = new Bun.CryptoHasher("sha256").update(secret + payload).digest("hex");
+    return Buffer.from(JSON.stringify({ payload, sig })).toString("base64");
 }
 
 function _defaultDeserialize(raw: string, secret: string): App.Locals {
-	const { payload, sig } = JSON.parse(Buffer.from(raw, "base64").toString());
-	const expected = new Bun.CryptoHasher("sha256")
-		.update(secret + payload)
-		.digest("hex");
-	if (sig !== expected) throw new Error("Grimoire: locals signature invalid");
-	return JSON.parse(payload);
+    const { payload, sig } = JSON.parse(Buffer.from(raw, "base64").toString());
+    const expected = new Bun.CryptoHasher("sha256").update(secret + payload).digest("hex");
+    if (sig !== expected) throw new Error("Grimoire: locals signature invalid");
+    return JSON.parse(payload);
 }