@plitzi/sdk-server 0.32.4 → 0.32.5

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @plitzi/sdk-server
 
+## 0.32.5
+
+### Patch Changes
+
+- v0.32.4
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.32.5
+  - @plitzi/sdk-shared@0.32.5
+
 ## 0.32.4
 
 ### Patch Changes

package/dist/adapters/jsonAdapters.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 //#region src/adapters/jsonAdapters.ts
 var isDeploymentObject = (v) => typeof v === "object" && ("spaceId" in v || "environment" in v || "error" in v);
 var readJson = (filePath) => JSON.parse(readFileSync(filePath, "utf-8"));
@@ -12,6 +12,10 @@ var createJsonAdapters = (config) => {
 			return Promise.resolve(void 0);
 		}
 	};
+	const saveOfflineData = (spaceId, environment, data) => {
+		writeFileSync(typeof config.offlineData === "function" ? config.offlineData(spaceId, environment) : config.offlineData, JSON.stringify(data, null, 2));
+		return Promise.resolve();
+	};
 	const getSpaceDeployment = (req) => {
 		const { deployment } = config;
 		if (!deployment) return Promise.resolve({
@@ -38,6 +42,7 @@ var createJsonAdapters = (config) => {
 	};
 	return {
 		getOfflineData,
+		saveOfflineData,
 		getSpaceDeployment,
 		getUser: config.user ? (req) => Promise.resolve(typeof config.user === "function" ? config.user(req) : config.user) : void 0
 	};

package/dist/core/createServer.js

@@ -1,47 +1,11 @@
-import { DEFAULT_TTL_MS } from "../helpers/cache/defaults.js";
-import { buildCacheManager } from "../helpers/cache/cacheManager.js";
-import { createServerCaches, destroyServerCaches } from "../helpers/cache/serverCaches.js";
-import { makeHandler } from "./requestHandler.js";
-import { buildTransport, protoLabel } from "./transports.js";
-import normalizePlugins, { normalizePluginSource } from "../helpers/normalizePlugins.js";
-import { compileTemplate } from "../modules/ssr/template.js";
-import { PluginManager } from "../plugins/manager.js";
+import { createMCPServer } from "./server/mcpServer.js";
+import { resolveServices } from "./services/resolve.js";
+import { createSSRServer } from "./server/ssrServer.js";
 //#region src/core/createServer.ts
-var createSSRServer = (config) => {
-	const { httpVersion: version = 2, cacheTtlMs: htmlTtlMs = DEFAULT_TTL_MS.html } = config;
-	if (version >= 3 && !config.tls) throw new Error(`[SSR] httpVersion: ${version} requires a tls config with key and cert`);
-	const caches = createServerCaches(htmlTtlMs, config.rsc?.cacheTtlMs ?? DEFAULT_TTL_MS.rsc);
-	const cache = caches.html ? buildCacheManager(caches.html) : null;
-	const renderFn = config.templateFn ?? compileTemplate();
-	const pluginManager = new PluginManager(normalizePlugins(config.plugins ?? {}), config.pluginsCacheDir, config.pluginsTtlMs, config.devMode);
-	const plugins = {
-		register: (name, source) => {
-			const normalized = normalizePluginSource(source);
-			pluginManager.register(`${name}@${normalized.version}`, normalized);
-		},
-		invalidate: (name, version) => pluginManager.invalidate(name, version)
-	};
-	let primary;
-	let h3;
-	return {
-		cache,
-		plugins,
-		listen(port, host = "0.0.0.0") {
-			const handler = makeHandler(config, port, renderFn, caches, pluginManager);
-			({primary, h3} = buildTransport(config, handler, port));
-			primary.listen(port, host, () => {
-				console.log(`[SSR] ${protoLabel(version, !!config.tls)} - listening on ${host}:${port}`);
-			});
-		},
-		async close() {
-			destroyServerCaches(caches);
-			pluginManager.destroy();
-			const closeOne = (srv) => new Promise((resolve, reject) => {
-				srv.close((err) => err ? reject(err) : resolve());
-			});
-			await Promise.all([closeOne(primary), ...h3 ? [closeOne(h3)] : []]);
-		}
-	};
+var createServer = (config) => {
+	const services = resolveServices(config);
+	if (services.mcp && !services.ssr && !services.rsc && !services.ai) return createMCPServer(config);
+	return createSSRServer(config);
 };
 //#endregion
-export { createSSRServer };
+export { createMCPServer, createSSRServer, createServer, resolveServices };

package/dist/core/health.js

@@ -0,0 +1,15 @@
+//#region src/core/health.ts
+var buildHealthPayload = (identity = {}) => ({
+	Server: identity.name ?? "SDK Server",
+	Version: identity.version ? `v${identity.version}` : "unknown",
+	role: identity.role
+});
+var registerHealthCheck = (app, identity) => {
+	const payload = buildHealthPayload(identity);
+	app.get("/health", (_req, res) => {
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify(payload));
+	});
+};
+//#endregion
+export { buildHealthPayload, registerHealthCheck };

package/dist/core/http/dispatcher.js

@@ -0,0 +1,29 @@
+import { applySecurityHeaders } from "./securityHeaders.js";
+import { buildResponseHelpers } from "../../helpers/buildResponseHelpers.js";
+import { parseRequest } from "../requestParser.js";
+//#region src/core/http/dispatcher.ts
+var runPipeline = async (raw, rawRes, buildContext, stages) => {
+	const req = parseRequest(raw);
+	const res = buildResponseHelpers(rawRes, req.headers["accept-encoding"]);
+	if (req.path === "\0") {
+		res.setStatus(400);
+		res.end();
+		return;
+	}
+	const ctx = buildContext(raw, rawRes, req, res);
+	applySecurityHeaders(res, ctx.config, ctx.port);
+	for (const stage of stages) if (await stage(ctx)) return;
+};
+var makeHandler = (label, buildContext, stages) => {
+	return (raw, rawRes) => {
+		runPipeline(raw, rawRes, buildContext, stages).catch((err) => {
+			console.error(`[${label}] Unhandled error:`, err);
+			try {
+				if (!rawRes.headersSent) rawRes.writeHead(500, { "Content-Type": "text/plain" });
+				rawRes.end("Internal Server Error");
+			} catch {}
+		});
+	};
+};
+//#endregion
+export { makeHandler };

package/dist/core/http/securityHeaders.js

@@ -0,0 +1,15 @@
+//#region src/core/http/securityHeaders.ts
+var applySecurityHeaders = (res, config, port) => {
+	res.setHeader("X-Content-Type-Options", "nosniff");
+	res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
+	res.setHeader("X-DNS-Prefetch-Control", "off");
+	const frameOptions = config.frameOptions === void 0 ? "DENY" : config.frameOptions;
+	if (frameOptions) if (Array.isArray(frameOptions)) res.setHeader("Content-Security-Policy", `frame-ancestors ${frameOptions.join(" ")}`);
+	else {
+		res.setHeader("X-Frame-Options", frameOptions);
+		res.setHeader("Content-Security-Policy", `frame-ancestors '${frameOptions === "DENY" ? "none" : "self"}'`);
+	}
+	if ((config.httpVersion ?? 2) >= 3) res.setHeader("Alt-Svc", `h3=":${port}"; ma=86400`);
+};
+//#endregion
+export { applySecurityHeaders };

package/dist/core/http/stages/authRoutes.js

@@ -0,0 +1,41 @@
+import { readRawBody } from "../../requestParser.js";
+//#region src/core/http/stages/authRoutes.ts
+var safeRedirectTarget = (req) => {
+	const redirectParam = req.query["redirect"];
+	return redirectParam && redirectParam.startsWith("/") && !redirectParam.startsWith("//") ? redirectParam : "/";
+};
+var loginStage = async (ctx) => {
+	const { config, raw, req, res } = ctx;
+	const loginPath = config.loginPath === false ? null : config.loginPath ?? "/auth/login";
+	if (!loginPath || req.method !== "POST" || req.path !== loginPath) return false;
+	req.body = await readRawBody(raw);
+	const isLoggedIn = await config.adapters.onLogin?.(req, res);
+	if (req.headers["sec-fetch-mode"] === "navigate") {
+		res.setStatus(303);
+		res.setHeader("Location", isLoggedIn ? safeRedirectTarget(req) : loginPath);
+		res.end();
+		return true;
+	}
+	res.setStatus(isLoggedIn ? 200 : 401);
+	res.end();
+	return true;
+};
+var logoutStage = async (ctx) => {
+	const { config, raw, req, res } = ctx;
+	const logoutPath = config.logoutPath === false ? null : config.logoutPath ?? "/auth/logout";
+	if (!logoutPath || req.method !== "POST" || req.path !== logoutPath) return false;
+	req.body = await readRawBody(raw);
+	await config.adapters.onLogout?.(req, res);
+	if (req.headers["sec-fetch-mode"] === "navigate") {
+		res.setStatus(303);
+		res.setHeader("Location", safeRedirectTarget(req));
+		res.end();
+		return true;
+	}
+	res.setStatus(204);
+	res.end();
+	return true;
+};
+var authRoutesStages = [loginStage, logoutStage];
+//#endregion
+export { authRoutesStages, loginStage, logoutStage };

package/dist/core/http/stages/health.js

@@ -0,0 +1,12 @@
+import { buildHealthPayload } from "../../health.js";
+//#region src/core/http/stages/health.ts
+var healthStage = (ctx) => {
+	const health = ctx.config.health;
+	if (ctx.req.path !== (health?.path ?? "/health")) return false;
+	ctx.res.setHeader("Content-Type", "application/json");
+	ctx.res.setStatus(200);
+	ctx.res.send(JSON.stringify(health?.payload ?? buildHealthPayload(health)));
+	return true;
+};
+//#endregion
+export { healthStage };

package/dist/core/http/stages/middlewares.js

@@ -0,0 +1,16 @@
+import { runMiddlewares } from "../../../helpers/runMiddlewares.js";
+import { authMiddleware } from "../../../middlewares/auth.js";
+import { basicAuthMiddleware } from "../../../middlewares/basicAuth.js";
+import { spaceDeploymentMiddleware } from "../../../middlewares/spaceDeployment.js";
+//#region src/core/http/stages/middlewares.ts
+var middlewaresStage = async (ctx) => {
+	const { config, req, res } = ctx;
+	return await runMiddlewares([
+		spaceDeploymentMiddleware(config.adapters),
+		basicAuthMiddleware({ cacheTtlMs: config.cacheTtlMs }),
+		authMiddleware(config.adapters),
+		...config.middlewares || []
+	], req, res) || res.status !== 200;
+};
+//#endregion
+export { middlewaresStage };

package/dist/core/http/stages/pluginAssets.js

@@ -0,0 +1,20 @@
+import { serveStatic } from "../../staticFiles.js";
+//#region src/core/http/stages/pluginAssets.ts
+var pluginAssetsStage = async (ctx) => {
+	const { pluginManager, req, res } = ctx;
+	if (!req.path.startsWith(pluginManager.urlPrefix + "/")) return false;
+	const relative = req.path.slice(pluginManager.urlPrefix.length);
+	const pluginName = relative.split("/")[1];
+	if (pluginName && pluginManager.hasPlugin(pluginName)) {
+		await pluginManager.prepare(pluginName);
+		if (serveStatic({
+			...req,
+			path: relative
+		}, res, pluginManager.outputDir)) return true;
+	}
+	res.setStatus(404);
+	res.send("Not found");
+	return true;
+};
+//#endregion
+export { pluginAssetsStage };

package/dist/core/http/stages/static.js

@@ -0,0 +1,30 @@
+import { serveStatic } from "../../staticFiles.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/core/http/stages/static.ts
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var BUILTIN_PUBLIC_DIR = path.resolve(__dirname, "../../../public");
+var builtinPublicStage = (ctx) => serveStatic(ctx.req, ctx.res, BUILTIN_PUBLIC_DIR);
+var publicDirStage = (ctx) => ctx.config.publicDir ? serveStatic(ctx.req, ctx.res, ctx.config.publicDir) : false;
+var wellKnownStage = (ctx) => {
+	if (!ctx.req.path.startsWith("/.well-known/")) return false;
+	ctx.res.setStatus(404);
+	ctx.res.end();
+	return true;
+};
+var configStaticStage = (ctx) => {
+	const { static: mounts } = ctx.config;
+	if (!mounts) return false;
+	for (const [prefix, rootDir] of Object.entries(mounts)) {
+		const normalizedPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+		if (ctx.req.path === prefix || ctx.req.path.startsWith(normalizedPrefix)) {
+			if (serveStatic({
+				...ctx.req,
+				path: ctx.req.path.slice(prefix.length) || "/"
+			}, ctx.res, rootDir)) return true;
+		}
+	}
+	return false;
+};
+//#endregion
+export { builtinPublicStage, configStaticStage, publicDirStage, wellKnownStage };

package/dist/core/server/baseServer.js

@@ -0,0 +1,29 @@
+import { buildTransport, protoLabel } from "../transports.js";
+//#region src/core/server/baseServer.ts
+var createHttpServer = (config, makeHandlerForPort, parts) => {
+	const { label } = parts;
+	const version = config.httpVersion ?? 2;
+	if (version >= 3 && !config.tls) throw new Error(`[${label}] httpVersion: ${version} requires a tls config with key and cert`);
+	let primary;
+	let h3;
+	return {
+		cache: parts.cache,
+		plugins: parts.plugins,
+		listen(port, host = "0.0.0.0") {
+			const handler = makeHandlerForPort(port);
+			({primary, h3} = buildTransport(config, handler, port, label));
+			primary.listen(port, host, () => {
+				console.log(`[${label}] ${protoLabel(version, !!config.tls)} - listening on ${host}:${port}`);
+			});
+		},
+		async close() {
+			parts.onDestroy?.();
+			const closeOne = (srv) => new Promise((resolve, reject) => {
+				srv.close((err) => err ? reject(err) : resolve());
+			});
+			await Promise.all([closeOne(primary), ...h3 ? [closeOne(h3)] : []]);
+		}
+	};
+};
+//#endregion
+export { createHttpServer };

package/dist/core/server/mcpServer.js

@@ -0,0 +1,29 @@
+import { createHttpServer } from "./baseServer.js";
+import { makeHandler } from "../http/dispatcher.js";
+import { buildMCPPipeline } from "../services/registry.js";
+//#region src/core/server/mcpServer.ts
+var noPlugins = {
+	register: () => void 0,
+	invalidate: () => Promise.resolve()
+};
+var createMCPServer = (config) => {
+	const stages = buildMCPPipeline();
+	const makeHandlerForPort = (port) => {
+		const buildContext = (raw, rawRes, req, res) => ({
+			raw,
+			rawRes,
+			req,
+			res,
+			config,
+			port
+		});
+		return makeHandler("MCP", buildContext, stages);
+	};
+	return createHttpServer(config, makeHandlerForPort, {
+		label: "MCP",
+		cache: null,
+		plugins: noPlugins
+	});
+};
+//#endregion
+export { createMCPServer };

package/dist/core/server/ssrServer.js

@@ -0,0 +1,54 @@
+import { createHttpServer } from "./baseServer.js";
+import { makeHandler } from "../http/dispatcher.js";
+import { DEFAULT_TTL_MS } from "../../helpers/cache/defaults.js";
+import { buildCacheManager } from "../../helpers/cache/cacheManager.js";
+import { createServerCaches, destroyServerCaches } from "../../helpers/cache/serverCaches.js";
+import { createMemoryDraftStore } from "../../modules/ssr/preview.js";
+import { buildSSRPipeline } from "../services/registry.js";
+import normalizePlugins, { normalizePluginSource } from "../../helpers/normalizePlugins.js";
+import { compileTemplate } from "../../modules/ssr/template.js";
+import { PluginManager } from "../../plugins/manager.js";
+import { resolveServices } from "../services/resolve.js";
+//#region src/core/server/ssrServer.ts
+var createSSRServer = (config) => {
+	const { cacheTtlMs: htmlTtlMs = DEFAULT_TTL_MS.html } = config;
+	if (config.preview?.enabled && !config.draftStore) config.draftStore = createMemoryDraftStore();
+	const services = resolveServices(config);
+	const caches = createServerCaches(htmlTtlMs, config.rsc?.cacheTtlMs ?? DEFAULT_TTL_MS.rsc);
+	const cache = caches.html ? buildCacheManager(caches.html) : null;
+	const renderFn = config.templateFn ?? compileTemplate();
+	const pluginManager = new PluginManager(normalizePlugins(config.plugins ?? {}), config.pluginsCacheDir, config.pluginsTtlMs, config.devMode);
+	const plugins = {
+		register: (name, source) => {
+			const normalized = normalizePluginSource(source);
+			pluginManager.register(`${name}@${normalized.version}`, normalized);
+		},
+		invalidate: (name, version) => pluginManager.invalidate(name, version)
+	};
+	const stages = buildSSRPipeline(services);
+	const makeHandlerForPort = (port) => {
+		const buildContext = (raw, rawRes, req, res) => ({
+			raw,
+			rawRes,
+			req,
+			res,
+			config,
+			port,
+			renderFn,
+			caches,
+			pluginManager
+		});
+		return makeHandler("SSR", buildContext, stages);
+	};
+	return createHttpServer(config, makeHandlerForPort, {
+		label: "SSR",
+		cache,
+		plugins,
+		onDestroy: () => {
+			destroyServerCaches(caches);
+			pluginManager.destroy();
+		}
+	});
+};
+//#endregion
+export { createSSRServer };

package/dist/core/services/mcp.js

@@ -0,0 +1,22 @@
+import { handleMcp } from "../../modules/mcp/handler.js";
+import { createHttpPreviewClient } from "../../modules/mcp/previewClient.js";
+import { createHttpScreenshotClient } from "../../modules/mcp/screenshotClient.js";
+//#region src/core/services/mcp.ts
+var mcpPathOf = (path) => path ?? "/";
+var serveMcp = (ctx) => {
+	const { previewClient, screenshot } = ctx.config;
+	const preview = previewClient ? createHttpPreviewClient(previewClient) : void 0;
+	const screenshotClient = screenshot ? createHttpScreenshotClient(screenshot) : void 0;
+	return handleMcp(ctx.raw, ctx.rawRes, ctx.req, ctx.config.adapters, preview, screenshotClient);
+};
+var mcpStage = async (ctx) => {
+	if (!ctx.req.path.startsWith(mcpPathOf(ctx.config.mcp?.path))) return false;
+	await serveMcp(ctx);
+	return true;
+};
+var mcpOnlyStage = async (ctx) => {
+	await serveMcp(ctx);
+	return true;
+};
+//#endregion
+export { mcpOnlyStage, mcpStage };

package/dist/core/services/preview.js

@@ -0,0 +1,37 @@
+import { readRawBody } from "../requestParser.js";
+import { createPreview } from "../../modules/ssr/preview.js";
+//#region src/core/services/preview.ts
+var PREVIEW_PATH_DEFAULT = "/__preview";
+var json = (ctx, status, payload) => {
+	ctx.res.setHeader("Content-Type", "application/json");
+	ctx.res.setStatus(status);
+	ctx.res.send(JSON.stringify(payload));
+	return true;
+};
+var previewStage = async (ctx) => {
+	const preview = ctx.config.preview;
+	const path = preview?.path ?? PREVIEW_PATH_DEFAULT;
+	if (!preview?.enabled || ctx.req.method !== "POST" || ctx.req.path !== path) return false;
+	if (preview.secret && ctx.req.headers["x-preview-secret"] !== preview.secret) return json(ctx, 403, {
+		error: "FORBIDDEN",
+		message: "Invalid or missing preview secret."
+	});
+	ctx.req.body = await readRawBody(ctx.raw);
+	let body;
+	try {
+		body = JSON.parse(ctx.req.body || "{}");
+	} catch {
+		return json(ctx, 400, {
+			error: "BAD_REQUEST",
+			message: "Request body must be JSON."
+		});
+	}
+	if (typeof body.spaceId !== "number") return json(ctx, 400, {
+		error: "BAD_REQUEST",
+		message: "spaceId (number) is required."
+	});
+	const result = await createPreview(body, ctx.config, ctx.renderFn, ctx.pluginManager, ctx.caches);
+	return json(ctx, result.ok ? 200 : 422, result);
+};
+//#endregion
+export { previewStage };

package/dist/core/services/registry.js

@@ -0,0 +1,30 @@
+import { mcpOnlyStage, mcpStage } from "./mcp.js";
+import { previewStage } from "./preview.js";
+import { rscStage } from "./rsc.js";
+import { notFoundStage, ssrStage } from "./ssr.js";
+import { authRoutesStages } from "../http/stages/authRoutes.js";
+import { healthStage } from "../http/stages/health.js";
+import { middlewaresStage } from "../http/stages/middlewares.js";
+import { pluginAssetsStage } from "../http/stages/pluginAssets.js";
+import { builtinPublicStage, configStaticStage, publicDirStage, wellKnownStage } from "../http/stages/static.js";
+//#region src/core/services/registry.ts
+var buildSSRPipeline = (services) => {
+	const stages = [
+		healthStage,
+		builtinPublicStage,
+		publicDirStage,
+		wellKnownStage,
+		pluginAssetsStage,
+		...authRoutesStages,
+		configStaticStage
+	];
+	if (services.mcp) stages.push(mcpStage);
+	stages.push(previewStage);
+	stages.push(middlewaresStage);
+	if (services.rsc) stages.push(rscStage);
+	stages.push(services.ssr ? ssrStage : notFoundStage);
+	return stages;
+};
+var buildMCPPipeline = () => [healthStage, mcpOnlyStage];
+//#endregion
+export { buildMCPPipeline, buildSSRPipeline };

package/dist/core/services/resolve.js

@@ -0,0 +1,12 @@
+//#region src/core/services/resolve.ts
+var resolveServices = (config) => {
+	const services = config.services ?? {};
+	return {
+		ssr: services.ssr ?? true,
+		rsc: services.rsc ?? !!config.adapters.getRscData,
+		mcp: services.mcp ?? config.mcpAi?.enabled ?? false,
+		ai: services.ai ?? false
+	};
+};
+//#endregion
+export { resolveServices };

package/dist/core/services/rsc.js

@@ -0,0 +1,11 @@
+import { handleRsc } from "../../modules/rsc/handler.js";
+//#region src/core/services/rsc.ts
+var rscStage = async (ctx) => {
+	const { config, req } = ctx;
+	const rscPath = config.rsc?.path ?? "/_rsc";
+	if (!(config.rsc?.enabled ?? true) || req.method !== "GET" || req.path !== rscPath) return false;
+	await handleRsc(req, ctx.res, config, ctx.pluginManager, ctx.caches.rsc);
+	return true;
+};
+//#endregion
+export { rscStage };

package/dist/core/services/ssr.js

@@ -0,0 +1,13 @@
+import { renderSSR } from "../../modules/ssr/handler.js";
+//#region src/core/services/ssr.ts
+var ssrStage = async (ctx) => {
+	await renderSSR(ctx.req, ctx.res, ctx.config, ctx.renderFn, ctx.pluginManager, ctx.caches);
+	return true;
+};
+var notFoundStage = (ctx) => {
+	ctx.res.setStatus(404);
+	ctx.res.end();
+	return true;
+};
+//#endregion
+export { notFoundStage, ssrStage };

package/dist/core/transports.js

@@ -2,9 +2,9 @@ import http from "node:http";
 import http2 from "node:http2";
 import https from "node:https";
 //#region src/core/transports.ts
-var tlsOptions = (config) => {
+var tlsOptions = (config, label = "Server") => {
 	const { tls } = config;
-	if (!tls) throw new Error("[SSR] TLS config required");
+	if (!tls) throw new Error(`[${label}] TLS config required`);
 	return {
 		key: tls.key,
 		cert: tls.cert,
@@ -16,31 +16,31 @@ var protoLabel = (version, hasTls) => {
 	if (version >= 2) return hasTls ? "HTTP/2 (TLS)" : "HTTP/1.1 - TLS Missing";
 	return hasTls ? "HTTPS/1.1" : "HTTP/1.1";
 };
-var buildTransport = (config, handler, port) => {
+var buildTransport = (config, handler, port, label = "Server") => {
 	const version = config.httpVersion ?? 2;
 	let primary;
 	let h3;
 	if (version >= 3) {
 		primary = http2.createSecureServer({
-			...tlsOptions(config),
+			...tlsOptions(config, label),
 			allowHTTP1: true
 		}, handler);
 		(async () => {
 			try {
-				h3 = (await import("node:http3")).createServer(tlsOptions(config), handler);
+				h3 = (await import("node:http3")).createServer(tlsOptions(config, label), handler);
 				h3.listen(port, "0.0.0.0", () => {
-					console.log(`[SSR] HTTP/3 (QUIC) listening on port ${port}`);
+					console.log(`[${label}] HTTP/3 (QUIC) listening on port ${port}`);
 				});
 			} catch {
-				console.warn("[SSR] HTTP/3 unavailable — start Node.js with --experimental-quic (requires Node ≥ 23). Falling back to HTTP/2.");
+				console.warn(`[${label}] HTTP/3 unavailable — start Node.js with --experimental-quic (requires Node ≥ 23). Falling back to HTTP/2.`);
 			}
 		})();
 	} else if (version >= 2) if (config.tls) primary = http2.createSecureServer({
-		...tlsOptions(config),
+		...tlsOptions(config, label),
 		allowHTTP1: true
 	}, handler);
 	else primary = http.createServer(handler);
-	else if (config.tls) primary = https.createServer(tlsOptions(config), handler);
+	else if (config.tls) primary = https.createServer(tlsOptions(config, label), handler);
 	else primary = http.createServer(handler);
 	return {
 		primary,

package/dist/index.js

@@ -1,8 +1,21 @@
-import { bindTools, getAllowedModes, isToolActive, resolveToolHandler, toolResponseErr, toolResponseOk, zodToJsonSchema } from "./modules/mcp/helpers.js";
-import { tools_exports } from "./modules/mcp/tools/index.js";
+import { operation } from "./modules/mcp/tools/operations/index.js";
+import { apply, applyShape } from "./modules/mcp/tools/apply/index.js";
+import { read, readShape } from "./modules/mcp/tools/read.js";
+import { search, searchShape } from "./modules/mcp/tools/search.js";
+import { validate, validateShape } from "./modules/mcp/tools/validate.js";
+import { tools } from "./modules/mcp/tools/index.js";
+import { bindTools, getAllowedModes, isCallToolResult, isToolActive, resolveToolHandler, toolResponseErr, toolResponseFromResult, toolResponseOk, zodToJsonSchema } from "./modules/ai/toolkit.js";
 import { createMcpServer } from "./modules/mcp/server.js";
-import AIEngine from "./modules/ai/AIEngine.js";
-import { handleMcp, readMcpBody } from "./modules/mcp/handler.js";
-import { createSSRServer } from "./core/createServer.js";
+import { handleMcp, readMcpBody, serveMcp } from "./modules/mcp/handler.js";
+import { createHttpPreviewClient } from "./modules/mcp/previewClient.js";
+import { PREVIEW_TOKEN_PARAM } from "./modules/mcp/constants.js";
+import { createHttpScreenshotClient } from "./modules/mcp/screenshotClient.js";
+import { createMemoryDraftStore, createPreview } from "./modules/ssr/preview.js";
+import { buildHealthPayload, registerHealthCheck } from "./core/health.js";
+import { createMCPServer } from "./core/server/mcpServer.js";
+import { resolveServices } from "./core/services/resolve.js";
+import { createSSRServer } from "./core/server/ssrServer.js";
+import { createServer } from "./core/createServer.js";
 import { createJsonAdapters } from "./adapters/jsonAdapters.js";
-export { AIEngine, bindTools, createJsonAdapters, createMcpServer, createSSRServer, getAllowedModes, handleMcp, isToolActive, readMcpBody, resolveToolHandler, toolResponseErr, toolResponseOk, tools_exports as tools, zodToJsonSchema };
+import AIEngine from "./modules/ai/AIEngine.js";
+export { AIEngine, PREVIEW_TOKEN_PARAM, apply, applyShape, bindTools, buildHealthPayload, createHttpPreviewClient, createHttpScreenshotClient, createJsonAdapters, createMCPServer, createMcpServer, createMemoryDraftStore, createPreview, createSSRServer, createServer, getAllowedModes, handleMcp, isCallToolResult, isToolActive, operation, read, readMcpBody, readShape, registerHealthCheck, resolveServices, resolveToolHandler, search, searchShape, serveMcp, toolResponseErr, toolResponseFromResult, toolResponseOk, tools, validate, validateShape, zodToJsonSchema };

package/dist/modules/ai/AIEngine.js

@@ -1,4 +1,4 @@
-import { toolResponseErr } from "../mcp/helpers.js";
+import { firstText, toolResponseErr } from "./toolkit.js";
 //#region src/modules/ai/AIEngine.ts
 var AIEngine = class {
 	mode;
@@ -44,12 +44,12 @@ var AIEngine = class {
 		let resultParsed;
 		if (result.data !== void 0) resultParsed = result.data;
 		else try {
-			resultParsed = JSON.parse(result.content[0]?.text ?? "");
+			resultParsed = JSON.parse(firstText(result.content) ?? "");
 		} catch {}
 		if (result.isError) this.callbacks.onToolError?.({
 			name,
 			args,
-			result: resultParsed ?? { error: result.content[0]?.text ?? "Tool failed" }
+			result: resultParsed ?? { error: firstText(result.content) ?? "Tool failed" }
 		});
 		else this.callbacks.onToolSuccess?.({
 			name,
@@ -96,7 +96,7 @@ var AIEngine = class {
 		if (outputError) this.callbacks.onLog?.("info", `tool output schema drift: ${name} — ${outputError}`);
 		const tool = this.toolsAvailables.get(name);
 		if (!result.isError && tool?.mcpDefinition.outputSchema && result.data !== void 0 && result.data !== null) result.structuredContent = typeof result.data === "object" && !Array.isArray(result.data) ? result.data : { data: result.data };
-		if (result.isError) this.callbacks.onLog?.("error", `tool failed: ${name} error=${result.content[0]?.text ?? "unknown"}`);
+		if (result.isError) this.callbacks.onLog?.("error", `tool failed: ${name} error=${firstText(result.content) ?? "unknown"}`);
 		await this.after(name, args, result);
 		return result;
 	};