camox 0.35.0 → 0.36.1

package/dist/features/runtime/runtime.js

@@ -1,8 +1,142 @@
-import "../routes/pageRuntime.js";
-import { QueryClient } from "@tanstack/react-query";
-import "@unhead/react/server";
+import { buildCamoxPageHead, createMarkdownResponse, createServerApiClient, isNotFoundError, loadCamoxPageForRequest } from "../routes/pageRuntime.js";
+import { QueryClient, dehydrate } from "@tanstack/react-query";
+import { createHead, renderSSRHead } from "@unhead/react/server";
 
 //#region src/features/runtime/runtime.ts
+const DEFAULT_RUNTIME_BASE_PATH = "";
+const RUNTIME_HEALTH_PATH = "/_camox/health";
+const RUNTIME_REGISTRY_PATH = "/_camox/registry";
+const SERVER_AUTH_COOKIE_NAME = "camox_auth_cookie";
+function buildClearServerAuthCookieHeader() {
+	return `${SERVER_AUTH_COOKIE_NAME}=; Path=/; SameSite=Lax; Max-Age=0`;
+}
+function getServerAuthCookieHeader(headers) {
+	const authCookie = (headers.get("Cookie") ?? headers.get("cookie") ?? "").split(";").map((part) => part.trim()).find((part) => part.startsWith(`${SERVER_AUTH_COOKIE_NAME}=`));
+	if (!authCookie) return "";
+	const value = authCookie.slice(18);
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return "";
+	}
+}
+function normalizeRuntimeBasePath(basePath) {
+	if (basePath === void 0) return DEFAULT_RUNTIME_BASE_PATH;
+	if (!basePath || basePath === "/") return "";
+	return basePath.startsWith("/") ? basePath.replace(/\/+$/, "") : `/${basePath.replace(/\/+$/, "")}`;
+}
+function getRuntimePathname(url, runtimeBasePath = DEFAULT_RUNTIME_BASE_PATH) {
+	const { pathname } = new URL(url);
+	const basePath = normalizeRuntimeBasePath(runtimeBasePath);
+	if (!basePath) return pathname || "/";
+	if (pathname === basePath) return "/";
+	if (!pathname.startsWith(`${basePath}/`)) return null;
+	return pathname.slice(basePath.length) || "/";
+}
+function escapeXml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+function normalizePagePath(path) {
+	if (!path) return "/";
+	return path.startsWith("/") ? path : `/${path}`;
+}
+function getLayoutIdentity(data, source) {
+	const layout = data.page.layout;
+	if (!layout) return null;
+	const version = source === "live" ? String(layout.livePublishedCheckpointId ?? "none") : String(layout.contentUpdatedAt ?? layout.updatedAt);
+	return {
+		blockIds: [...layout.beforeBlockIds, ...layout.afterBlockIds],
+		id: layout.id,
+		layoutId: layout.layoutId,
+		version
+	};
+}
+function matchRuntimeRoute(pathname) {
+	if (pathname === RUNTIME_HEALTH_PATH) return {
+		kind: "health",
+		pathname
+	};
+	if (pathname === RUNTIME_REGISTRY_PATH) return {
+		kind: "registry",
+		pathname
+	};
+	if (pathname === "/_camox/data") return {
+		kind: "data",
+		pathname
+	};
+	if (pathname === "/camox") return {
+		kind: "studio",
+		pathname
+	};
+	if (pathname === "/camox/content") return {
+		kind: "studio-content",
+		pathname
+	};
+	if (pathname.startsWith("/camox/")) return {
+		kind: "studio-nested",
+		pathname
+	};
+	if (pathname === "/og") return {
+		kind: "og",
+		pathname
+	};
+	if (pathname === "/sitemap.xml") return {
+		kind: "sitemap",
+		pathname
+	};
+	return {
+		kind: "page",
+		pathname
+	};
+}
+function withRuntimeBasePath(pathname, runtimeBasePath) {
+	const basePath = normalizeRuntimeBasePath(runtimeBasePath);
+	if (!basePath) return pathname;
+	if (pathname === "/") return `${basePath}/`;
+	return `${basePath}${pathname}`;
+}
+async function createSitemapResponse(request, options) {
+	if (!options.apiUrl || !options.projectSlug) return Response.json({ message: "Camox sitemap is not configured." }, { status: 500 });
+	const api = createServerApiClient(options.apiUrl, options.environmentName);
+	const origin = new URL(request.url).origin;
+	const entries = (await api.pages.listBySlug({ projectSlug: options.projectSlug })).map((page) => `  <url>
+    <loc>${escapeXml(`${origin}${withRuntimeBasePath(page.fullPath, options.runtimeBasePath)}`)}</loc>
+    <lastmod>${escapeXml(new Date(page.updatedAt).toISOString())}</lastmod>
+  </url>`).join("\n");
+	return new Response(`<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${entries}
+</urlset>`, { headers: { "Content-Type": "application/xml; charset=utf-8" } });
+}
+async function createOgResponse(request, options) {
+	const camoxApp = await options.getCamoxApp?.();
+	if (!camoxApp) return Response.json({ message: "Camox app registry is not available." }, { status: 500 });
+	const url = new URL(request.url);
+	const layoutId = url.searchParams.get("layoutId") || "";
+	const title = url.searchParams.get("title") || "";
+	const description = url.searchParams.get("description") || "";
+	const projectName = url.searchParams.get("projectName") || "";
+	const layout = camoxApp.getLayoutById(layoutId);
+	if (!layout?._internal.buildOgImage) return new Response("Not found", { status: 404 });
+	return layout._internal.buildOgImage({
+		title,
+		description,
+		projectName
+	});
+}
+function createDefaultHeadInput(stylesheetUrl) {
+	return {
+		htmlAttrs: { lang: "en" },
+		meta: [{ charset: "utf-8" }, {
+			name: "viewport",
+			content: "width=device-width, initial-scale=1"
+		}],
+		link: stylesheetUrl ? [{
+			rel: "stylesheet",
+			href: stylesheetUrl
+		}] : []
+	};
+}
 function createPageHeadInput(head) {
 	const meta = head.meta ?? [];
 	const links = head.links ?? [];
@@ -39,6 +173,211 @@ function createPageHeadInput(head) {
 		link: pageLinks
 	};
 }
+function renderHead(document, pageHead, stylesheetUrl) {
+	const head = createHead();
+	head.push(createDefaultHeadInput(stylesheetUrl));
+	head.push(document);
+	head.push(pageHead);
+	return renderSSRHead(head);
+}
+function serializeJsonForHtml(value) {
+	return JSON.stringify(value).replaceAll("<", "\\u003c");
+}
+function renderClientEntryScript(src) {
+	if (!src) return "";
+	return `<script type="module" src="${escapeXml(src)}"><\/script>`;
+}
+async function createPageHtmlResponse({ options, pathname, request }) {
+	if (!options.apiUrl || !options.authenticationUrl || !options.projectSlug || !options.renderPage) return createPageDataResponse({
+		options,
+		pathname,
+		request
+	});
+	const queryClient = new QueryClient();
+	try {
+		const result = await loadCamoxPageForRequest({
+			apiUrl: options.apiUrl,
+			authCookieHeader: getServerAuthCookieHeader(request.headers),
+			environmentName: options.environmentName,
+			origin: new URL(request.url).origin,
+			pathname,
+			projectSlug: options.projectSlug,
+			queryClient
+		});
+		const headers = new Headers({ "Content-Type": "text/html; charset=utf-8" });
+		if (result.shouldClearAuthCookie) headers.append("Set-Cookie", buildClearServerAuthCookieHeader());
+		const camoxApp = await options.getCamoxApp?.();
+		const document = await options.getDocument?.() ?? {};
+		const head = camoxApp ? buildCamoxPageHead(camoxApp, result.data) : {};
+		const dehydratedState = dehydrate(queryClient);
+		const pageRenderInput = {
+			apiUrl: options.apiUrl,
+			authenticationUrl: options.authenticationUrl,
+			dehydratedState,
+			environmentName: options.environmentName,
+			head,
+			href: new URL(request.url).href,
+			layoutIdentity: getLayoutIdentity(result.data, result.source),
+			loaderData: result.data,
+			pathname,
+			projectSlug: options.projectSlug,
+			runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath),
+			source: result.source
+		};
+		const appHtml = await options.renderPage(pageRenderInput);
+		const renderedHead = renderHead(document, createPageHeadInput(head), options.stylesheetUrl);
+		return new Response(`<!doctype html>
+<html${renderedHead.htmlAttrs}>
+<head>
+${renderedHead.headTags}
+<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(pageRenderInput)}<\/script>
+</head>
+<body${renderedHead.bodyAttrs}>
+${renderedHead.bodyTagsOpen}
+<div id="root">${appHtml}</div>
+${renderedHead.bodyTags}
+${renderClientEntryScript(options.pageClientEntryUrl)}
+</body>
+</html>`, { headers });
+	} catch (error) {
+		if (isNotFoundError(error)) return new Response("No Camox page on this path", { status: 404 });
+		throw error;
+	}
+}
+async function createStudioHtmlResponse({ match, options, request }) {
+	if (!options.apiUrl || !options.authenticationUrl || !options.projectSlug || !options.renderStudio) return Response.json({
+		message: "Camox Studio renderer is not configured.",
+		...match
+	}, { status: 500 });
+	const queryClient = new QueryClient();
+	const document = await options.getDocument?.() ?? {};
+	const studioRenderInput = {
+		apiUrl: options.apiUrl,
+		authenticationUrl: options.authenticationUrl,
+		dehydratedState: dehydrate(queryClient),
+		environmentName: options.environmentName,
+		href: new URL(request.url).href,
+		pathname: match.pathname,
+		projectSlug: options.projectSlug,
+		routeKind: match.kind,
+		runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath)
+	};
+	const appHtml = await options.renderStudio(studioRenderInput);
+	const renderedHead = renderHead(document, {}, options.stylesheetUrl);
+	return new Response(`<!doctype html>
+<html${renderedHead.htmlAttrs}>
+<head>
+${renderedHead.headTags}
+<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(studioRenderInput)}<\/script>
+</head>
+<body${renderedHead.bodyAttrs}>
+${renderedHead.bodyTagsOpen}
+<div id="root">${appHtml}</div>
+${renderedHead.bodyTags}
+${renderClientEntryScript(options.studioClientEntryUrl)}
+</body>
+</html>`, { headers: { "Content-Type": "text/html; charset=utf-8" } });
+}
+async function createPageDataResponse({ options, pathname, request }) {
+	if (!options.apiUrl || !options.projectSlug) return Response.json({ message: "Camox page loader is not configured." }, { status: 500 });
+	const queryClient = new QueryClient();
+	try {
+		const result = await loadCamoxPageForRequest({
+			apiUrl: options.apiUrl,
+			authCookieHeader: getServerAuthCookieHeader(request.headers),
+			environmentName: options.environmentName,
+			origin: new URL(request.url).origin,
+			pathname,
+			projectSlug: options.projectSlug,
+			queryClient
+		});
+		const headers = new Headers({ "Content-Type": "application/json; charset=utf-8" });
+		if (result.shouldClearAuthCookie) headers.append("Set-Cookie", buildClearServerAuthCookieHeader());
+		const camoxApp = await options.getCamoxApp?.();
+		const head = camoxApp ? buildCamoxPageHead(camoxApp, result.data) : null;
+		const dehydratedState = dehydrate(queryClient);
+		const { page, layout, projectName, project } = result.data.page;
+		return new Response(`${JSON.stringify({
+			kind: "page",
+			pathname,
+			page: {
+				id: page.id,
+				fullPath: page.fullPath,
+				metaTitle: page.metaTitle,
+				metaDescription: page.metaDescription
+			},
+			layout: layout ? {
+				id: layout.id,
+				layoutId: layout.layoutId
+			} : null,
+			layoutIdentity: getLayoutIdentity(result.data, result.source),
+			project: {
+				id: project.id,
+				name: projectName
+			},
+			loaderData: {
+				faviconUrl: result.data.faviconUrl,
+				origin: result.data.origin
+			},
+			head,
+			dehydratedState
+		}, null, 2)}\n`, { headers });
+	} catch (error) {
+		if (isNotFoundError(error)) return Response.json({
+			kind: "page",
+			message: "No Camox page on this path",
+			pathname
+		}, { status: 404 });
+		throw error;
+	}
+}
+async function handleCamoxRequest(request, options = {}) {
+	const pathname = getRuntimePathname(request.url, options.runtimeBasePath);
+	if (!pathname) return null;
+	const match = matchRuntimeRoute(pathname);
+	if (match.kind === "health") return new Response("ok\n", { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+	if (match.kind === "registry") {
+		const camoxApp = await options.getCamoxApp?.();
+		if (!camoxApp) return Response.json({ message: "Camox app registry is not available." }, { status: 500 });
+		return Response.json({
+			blocks: camoxApp.getBlocks().map((block) => block._internal.id),
+			layouts: camoxApp.getLayouts().map((layout) => layout._internal.id)
+		});
+	}
+	if (match.kind === "og") return createOgResponse(request, options);
+	if (match.kind === "sitemap") return createSitemapResponse(request, options);
+	if (match.kind === "data") return createPageDataResponse({
+		options,
+		pathname: normalizePagePath(new URL(request.url).searchParams.get("path")),
+		request
+	});
+	if (match.kind === "studio" || match.kind === "studio-content" || match.kind === "studio-nested") return createStudioHtmlResponse({
+		match,
+		options,
+		request
+	});
+	if (match.kind === "page") {
+		if (options.apiUrl && options.projectSlug) {
+			const markdownResponse = await createMarkdownResponse({
+				apiUrl: options.apiUrl,
+				environmentName: options.environmentName,
+				pathname: match.pathname,
+				projectSlug: options.projectSlug,
+				request
+			});
+			if (markdownResponse) return markdownResponse;
+		}
+		return createPageHtmlResponse({
+			options,
+			pathname: match.pathname,
+			request
+		});
+	}
+	return Response.json({
+		message: "Camox runtime route matched.",
+		...match
+	}, { status: 501 });
+}
 
 //#endregion
-export { createPageHeadInput };
+export { createPageHeadInput, getRuntimePathname, handleCamoxRequest, matchRuntimeRoute };

package/dist/features/runtime/studioNavigation.js

@@ -39,9 +39,9 @@ function getStudioTarget(to, runtimeBasePath) {
 }
 function StudioNavigationProvider(t0) {
 	const $ = c(19);
-	if ($[0] !== "df5809d38cc8796db839fa5b8c8d05f562a3e4cba7d51a1fec989dc85db9136b") {
+	if ($[0] !== "8131144acb7b9faccf5f5924d863b9186349bfc7c842e7feba7a3ac1e01ed910") {
 		for (let $i = 0; $i < 19; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "df5809d38cc8796db839fa5b8c8d05f562a3e4cba7d51a1fec989dc85db9136b";
+		$[0] = "8131144acb7b9faccf5f5924d863b9186349bfc7c842e7feba7a3ac1e01ed910";
 	}
 	const { children, href, pathname, runtimeBasePath } = t0;
 	let t1;
@@ -53,6 +53,11 @@ function StudioNavigationProvider(t0) {
 				window.location.assign(to);
 				return;
 			}
+			const currentPathname = normalizeRuntimePathname(window.location.pathname, runtimeBasePath);
+			if (normalizeRuntimePathname(target.pathname, runtimeBasePath) !== currentPathname) {
+				window.location.assign(target.href);
+				return;
+			}
 			if (replace) window.history.replaceState(null, "", target.href);
 			else window.history.pushState(null, "", target.href);
 			window.dispatchEvent(new Event("camox:navigation"));

package/dist/features/studio/components/Navbar.js

@@ -36,9 +36,9 @@ const links = [{
 }];
 const Navbar = () => {
 	const $ = c(19);
-	if ($[0] !== "9b1adcbc6464388cc572701469e917a5652b82c7ccc4e66be74fb1820176f49e") {
+	if ($[0] !== "4fd5828728ac76dc7c63a1b38dbea3991a6750be46540e90d91c5dccb46797e2") {
 		for (let $i = 0; $i < 19; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "9b1adcbc6464388cc572701469e917a5652b82c7ccc4e66be74fb1820176f49e";
+		$[0] = "4fd5828728ac76dc7c63a1b38dbea3991a6750be46540e90d91c5dccb46797e2";
 	}
 	const projectSlug = useProjectSlug();
 	let t0;
@@ -136,7 +136,7 @@ const Navbar = () => {
 	let t10;
 	if ($[17] !== t6) {
 		t10 = /* @__PURE__ */ jsxs("nav", {
-			className: "relative flex items-center justify-between gap-4 border-b-2 bg-transparent px-2 py-2",
+			className: "bg-background relative flex items-center justify-between gap-4 border-b-2 px-2 py-2",
 			children: [t6, t9]
 		});
 		$[17] = t6;
@@ -146,9 +146,9 @@ const Navbar = () => {
 };
 function useNavbarActions() {
 	const $ = c(4);
-	if ($[0] !== "9b1adcbc6464388cc572701469e917a5652b82c7ccc4e66be74fb1820176f49e") {
+	if ($[0] !== "4fd5828728ac76dc7c63a1b38dbea3991a6750be46540e90d91c5dccb46797e2") {
 		for (let $i = 0; $i < 4; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "9b1adcbc6464388cc572701469e917a5652b82c7ccc4e66be74fb1820176f49e";
+		$[0] = "4fd5828728ac76dc7c63a1b38dbea3991a6750be46540e90d91c5dccb46797e2";
 	}
 	const navigate = useNavigate();
 	let t0;

package/dist/features/studio/components/ProjectMenu.js

@@ -13,9 +13,9 @@ import { Skeleton } from "@camox/ui/skeleton";
 //#region src/features/studio/components/ProjectMenu.tsx
 const Favicon = (t0) => {
 	const $ = c(19);
-	if ($[0] !== "5b6284d7940526e6093811e0cb2663e0916c58abe0f07e36b7140e4a9eb93d0f") {
+	if ($[0] !== "d995cbe0a8e25c463e5078777395b1432b84ff5ecc4a4a3cc0e7e416badd244d") {
 		for (let $i = 0; $i < 19; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "5b6284d7940526e6093811e0cb2663e0916c58abe0f07e36b7140e4a9eb93d0f";
+		$[0] = "d995cbe0a8e25c463e5078777395b1432b84ff5ecc4a4a3cc0e7e416badd244d";
 	}
 	const { size: t1 } = t0;
 	const size = t1 === void 0 ? 16 : t1;
@@ -113,9 +113,9 @@ const Favicon = (t0) => {
 };
 const ProjectMenu = () => {
 	const $ = c(41);
-	if ($[0] !== "5b6284d7940526e6093811e0cb2663e0916c58abe0f07e36b7140e4a9eb93d0f") {
+	if ($[0] !== "d995cbe0a8e25c463e5078777395b1432b84ff5ecc4a4a3cc0e7e416badd244d") {
 		for (let $i = 0; $i < 41; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "5b6284d7940526e6093811e0cb2663e0916c58abe0f07e36b7140e4a9eb93d0f";
+		$[0] = "d995cbe0a8e25c463e5078777395b1432b84ff5ecc4a4a3cc0e7e416badd244d";
 	}
 	const authCtx = React.useContext(AuthContext);
 	let t0;
@@ -282,7 +282,7 @@ const ProjectMenu = () => {
 	if ($[34] === Symbol.for("react.memo_cache_sentinel")) {
 		t22 = /* @__PURE__ */ jsxs(DropdownMenuItem, {
 			render: /* @__PURE__ */ jsx(Link$1, {
-				to: "https://camox.ai",
+				to: "https://camox.dev",
 				target: "_blank"
 			}),
 			children: [/* @__PURE__ */ jsx(Info, { className: "h-4 w-4" }), "Powered by Camox"]

package/dist/features/vite/vite.d.ts

@@ -28,7 +28,7 @@ interface CamoxPluginOptions {
   disableTelemetry?: boolean;
   /** Internal options (intended for Camox contributors in development, not for public use) */
   _internal?: {
-    /** URL of the Camox API backend, used for data fetching */apiUrl?: string; /** URL of the Camox authentication backend (default: https://app.camox.ai) */
+    /** URL of the Camox API backend, used for data fetching */apiUrl?: string; /** URL of the Camox authentication backend (default: https://app.camox.dev) */
     authenticationUrl?: string; /** Show Tanstack query devtools (default: false) */
     enableTanstackDevtools?: boolean; /** Disable automatic code generation (route files, app file, skill files) (default: false) */
     disableCodeGen?: boolean; /** Mount the Camox-owned dev runtime at this base path. Use "/" for root mode. */

package/dist/features/vite/vite.js

@@ -21,9 +21,9 @@ const VIRTUAL_PAGE_CLIENT = "virtual:camox/page-client";
 const RESOLVED_VIRTUAL_PAGE_CLIENT_URL = "\0virtual:camox/page-client-url";
 const VIRTUAL_STUDIO_CLIENT = "virtual:camox/studio-client";
 const RESOLVED_VIRTUAL_STUDIO_CLIENT_URL = "\0virtual:camox/studio-client-url";
-const PRODUCTION_API_URL = "https://api.camox.ai";
+const PRODUCTION_API_URL = "https://api.camox.dev";
 /** Authentication URL to use for Camox authentication (production Camox Dashboard) */
-const DEFAULT_AUTHENTICATION_URL = "https://app.camox.ai";
+const DEFAULT_AUTHENTICATION_URL = "https://app.camox.dev";
 const authTokenSchema = z.object({
 	token: z.string(),
 	name: z.string(),

package/dist/lib/telemetry-client.js

@@ -8,7 +8,7 @@ function ensureInitialized() {
 	if (typeof window === "undefined") return false;
 	if (initialized) return true;
 	posthog.init(POSTHOG_PUBLIC_KEY, {
-		api_host: "https://t.camox.ai",
+		api_host: "https://t.camox.dev",
 		ui_host: "https://us.posthog.com",
 		defaults: "2026-01-30",
 		autocapture: false,
@@ -56,7 +56,7 @@ function identifyProject(options) {
 		slug: options.projectSlug
 	});
 }
-/** Client-side tracking for CMS actions. Events route through t.camox.ai reverse proxy. */
+/** Client-side tracking for CMS actions. Events route through t.camox.dev reverse proxy. */
 function trackClientEvent(event, properties) {
 	if (!ensureInitialized()) return;
 	posthog.capture(event, properties);

package/dist/lib/telemetry.js

@@ -1,3 +1,26 @@
 import { POSTHOG_PUBLIC_KEY } from "@camox/api-contract";
 
-export {  };
+//#region src/lib/telemetry.ts
+let client = null;
+async function getClient() {
+	if (__CAMOX_TELEMETRY_DISABLED__) return null;
+	if (!client) {
+		const { PostHog } = await import("posthog-node");
+		client = new PostHog(POSTHOG_PUBLIC_KEY, { host: "https://us.i.posthog.com" });
+	}
+	return client;
+}
+/** Server-side tracking for page views (used in pageRoute.tsx) */
+async function trackEvent(event, properties) {
+	const posthog = await getClient();
+	if (!posthog) return;
+	const distinctId = properties.projectId ?? "unknown";
+	posthog.capture({
+		distinctId,
+		event,
+		properties
+	});
+}
+
+//#endregion
+export { trackEvent };