@rimelight/cms 0.0.3 → 0.0.4

package/dist/schema/sqlite.mjs

@@ -0,0 +1,137 @@
+import { sql } from "drizzle-orm";
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+//#region src/schema/sqlite.ts
+const pageTemplates = sqliteTable("page_templates", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	slug: text("slug").notNull().unique(),
+	title: text("title", { mode: "json" }).$type().notNull(),
+	description: text("description", { mode: "json" }).$type(),
+	pageType: text("page_type").$type().notNull(),
+	version: integer("version").default(1).notNull(),
+	allowedRoles: text("allowed_roles", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	rolePermissions: text("role_permissions", { mode: "json" }).$type().default(sql`'{"whoCanCreate":[],"whoCanEdit":[],"whoCanReview":[],"whoCanView":[]}'`).notNull(),
+	requiredPermission: text("required_permission"),
+	approvalRules: text("approval_rules", { mode: "json" }).$type().default(sql`'{"allowSelfApproval":true,"minApprovals":1}'`).notNull(),
+	defaultProperties: text("default_properties", { mode: "json" }).default(sql`'{}'`).notNull(),
+	initialBlocks: text("initial_blocks", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$onUpdate(() => /* @__PURE__ */ new Date())
+});
+const pageVersions = sqliteTable("page_versions", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	pageId: text("page_id").notNull(),
+	versionNumber: integer("version_number").notNull(),
+	status: text("status").$type().default("pending").notNull(),
+	slug: text("slug").notNull(),
+	type: text("type").$type().notNull(),
+	title: text("title", { mode: "json" }).$type().notNull(),
+	description: text("description", { mode: "json" }).$type(),
+	tags: text("tags", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	authorIds: text("author_ids", { mode: "json" }).$type().default(sql`'[]'`),
+	bylines: text("bylines", { mode: "json" }).$type().default(sql`'[]'`),
+	content: text("content", { mode: "json" }).$type().notNull(),
+	createdBy: text("created_by").notNull(),
+	approvedBy: text("approved_by", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	approvedAt: integer("approved_at", { mode: "timestamp" }),
+	changeSummary: text("change_summary"),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+}, (table) => [uniqueIndex("page_versions_page_id_version_idx").on(table.pageId, table.versionNumber)]);
+const pages = sqliteTable("pages", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	slug: text("slug").notNull(),
+	type: text("type").$type().notNull(),
+	templateId: text("template_id").references(() => pageTemplates.id, { onDelete: "set null" }),
+	templateVersion: integer("template_version").default(1).notNull(),
+	title: text("title", { mode: "json" }).$type().notNull(),
+	description: text("description", { mode: "json" }).$type(),
+	tags: text("tags", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	authorIds: text("author_ids", { mode: "json" }).$type().default(sql`'[]'`),
+	bylines: text("bylines", { mode: "json" }).$type().default(sql`'[]'`),
+	content: text("content", { mode: "json" }).$type().notNull(),
+	publishedVersionId: text("published_version_id").references(() => pageVersions.id, { onDelete: "set null" }),
+	postedAt: integer("posted_at", { mode: "timestamp" }),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$onUpdate(() => /* @__PURE__ */ new Date()),
+	deletedAt: integer("deleted_at", { mode: "timestamp" })
+}, (table) => [uniqueIndex("pages_slug_active_unique_idx").on(table.slug).where(sql`deleted_at IS NULL`)]);
+const pageDrafts = sqliteTable("page_drafts", {
+	pageId: text("page_id").notNull().primaryKey().references(() => pages.id, { onDelete: "cascade" }),
+	content: text("content", { mode: "json" }).$type().notNull(),
+	updatedBy: text("updated_by").notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+});
+const pageDraftLocks = sqliteTable("page_draft_locks", {
+	pageId: text("page_id").notNull().primaryKey().references(() => pages.id, { onDelete: "cascade" }),
+	lockedByUserId: text("locked_by_user_id").notNull(),
+	lockedByUserName: text("locked_by_user_name").notNull(),
+	acquiredAt: integer("acquired_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	expiresAt: integer("expires_at", { mode: "timestamp" }).notNull()
+});
+const pageVersionApprovals = sqliteTable("page_version_approvals", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	versionId: text("version_id").notNull().references(() => pageVersions.id, { onDelete: "cascade" }),
+	userId: text("user_id").notNull(),
+	userRole: text("user_role").notNull(),
+	approvedAt: integer("approved_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+});
+const pageVersionComments = sqliteTable("page_version_comments", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	versionId: text("version_id").notNull().references(() => pageVersions.id, { onDelete: "cascade" }),
+	userId: text("user_id").notNull(),
+	userRole: text("user_role").notNull(),
+	content: text("content").notNull(),
+	blockId: text("block_id"),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+});
+const contentSearchIndex = sqliteTable("content_search_index", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	pageId: text("page_id").notNull().references(() => pages.id, { onDelete: "cascade" }),
+	locale: text("locale").notNull(),
+	titleText: text("title_text").notNull(),
+	contentText: text("content_text").notNull()
+}, (table) => [index("content_search_index_page_id_idx").on(table.pageId)]);
+const siteSettings = sqliteTable("site_settings", {
+	id: text("id").primaryKey().default("default"),
+	name: text("name").notNull(),
+	description: text("description").notNull(),
+	url: text("url").notNull(),
+	ogImage: text("og_image").notNull(),
+	author: text("author").notNull(),
+	email: text("email").notNull().default(""),
+	branding: text("branding", { mode: "json" }).$type().notNull(),
+	seo: text("seo", { mode: "json" }).$type().notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
+});
+const taxonomyTerms = sqliteTable("taxonomy_terms", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	taxonomy: text("taxonomy").notNull(),
+	slug: text("slug").notNull(),
+	label: text("label", { mode: "json" }).$type().notNull(),
+	description: text("description", { mode: "json" }).$type(),
+	parentId: text("parent_id").references(() => taxonomyTerms.id, { onDelete: "cascade" }),
+	displayOrder: integer("display_order").default(0).notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$onUpdate(() => /* @__PURE__ */ new Date())
+}, (table) => [uniqueIndex("taxonomy_terms_tax_slug_idx").on(table.taxonomy, table.slug)]);
+const pageTaxonomyTerms = sqliteTable("page_taxonomy_terms", {
+	pageId: text("page_id").notNull().references(() => pages.id, { onDelete: "cascade" }),
+	termId: text("term_id").notNull().references(() => taxonomyTerms.id, { onDelete: "cascade" }),
+	assignedAt: integer("assigned_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+}, (table) => [uniqueIndex("page_taxonomy_terms_page_term_idx").on(table.pageId, table.termId)]);
+const bylines = sqliteTable("bylines", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).primaryKey(),
+	name: text("name").notNull(),
+	slug: text("slug").notNull(),
+	websiteUrl: text("website_url"),
+	bio: text("bio"),
+	avatar: text("avatar"),
+	userId: text("user_id"),
+	socials: text("socials", { mode: "json" }).$type().default(sql`'{}'`),
+	metadata: text("metadata", { mode: "json" }).$type().default(sql`'{}'`),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	deletedAt: integer("deleted_at", { mode: "timestamp" })
+}, (table) => [uniqueIndex("bylines_slug_idx").on(table.slug)]);
+//#endregion
+export { bylines, contentSearchIndex, pageDraftLocks, pageDrafts, pageTaxonomyTerms, pageTemplates, pageVersionApprovals, pageVersionComments, pageVersions, pages, siteSettings, taxonomyTerms };

package/dist/storage/index.d.mts

@@ -0,0 +1,59 @@
+//#region src/storage/index.d.ts
+interface StorageFile {
+  key: string;
+  name: string;
+  size: number;
+  mimeType: string;
+  uploadedAt: string;
+  url: string;
+  etag?: string;
+  customMetadata?: Record<string, string>;
+}
+interface StorageListResult {
+  files: StorageFile[];
+  truncated: boolean;
+  cursor?: string;
+}
+interface R2StorageOptions {
+  binding?: string | undefined;
+  publicUrl?: string | undefined;
+  prefix?: string | undefined;
+}
+interface StorageConfig {
+  provider: "r2" | "local" | "s3";
+  binding?: string | undefined;
+  publicUrl?: string | undefined;
+  prefix?: string | undefined;
+}
+interface StorageListOptions {
+  prefix?: string | undefined;
+  cursor?: string | undefined;
+  limit?: number | undefined;
+  publicUrl?: string | undefined;
+  apiBasePath?: string | undefined;
+}
+interface StorageUploadOptions {
+  key?: string | undefined;
+  prefix?: string | undefined;
+  publicUrl?: string | undefined;
+  apiBasePath?: string | undefined;
+}
+declare function r2(options?: R2StorageOptions): StorageConfig;
+/**
+ * Resolves Cloudflare R2 bucket instance from Cloudflare env or Astro locals.
+ */
+declare function getR2Bucket(locals?: any, bindingName?: string): Promise<any>;
+/**
+ * Lists files from R2 Bucket under configured prefix.
+ */
+declare function listR2Files(bucket: any, options?: StorageListOptions): Promise<StorageListResult>;
+/**
+ * Uploads a file buffer/stream into R2 Bucket.
+ */
+declare function uploadR2File(bucket: any, file: File, options?: StorageUploadOptions): Promise<StorageFile>;
+/**
+ * Deletes a file from R2 Bucket by key.
+ */
+declare function deleteR2File(bucket: any, key: string): Promise<boolean>;
+//#endregion
+export { R2StorageOptions, StorageConfig, StorageFile, StorageListOptions, StorageListResult, StorageUploadOptions, deleteR2File, getR2Bucket, listR2Files, r2, uploadR2File };

package/dist/storage/index.mjs

@@ -0,0 +1,133 @@
+//#region src/storage/index.ts
+function r2(options = {}) {
+	return {
+		provider: "r2",
+		binding: options.binding ?? "BLOB",
+		publicUrl: options.publicUrl,
+		prefix: options.prefix ?? "media/"
+	};
+}
+/**
+* Resolves Cloudflare R2 bucket instance from Cloudflare env or Astro locals.
+*/
+async function getR2Bucket(locals, bindingName = "BLOB") {
+	try {
+		const cf = await import("cloudflare:workers");
+		if (cf?.env && cf.env[bindingName]) return cf.env[bindingName];
+	} catch {}
+	if (locals) {
+		if (locals.runtime?.env && locals.runtime.env[bindingName]) return locals.runtime.env[bindingName];
+		if (locals.env && locals.env[bindingName]) return locals.env[bindingName];
+		if (locals[bindingName]) return locals[bindingName];
+	}
+	if (typeof process !== "undefined" && process.env && process.env[bindingName]) return process.env[bindingName];
+	return null;
+}
+/**
+* Lists files from R2 Bucket under configured prefix.
+*/
+async function listR2Files(bucket, options = {}) {
+	if (!bucket || typeof bucket.list !== "function") return {
+		files: [],
+		truncated: false
+	};
+	const prefix = options.prefix ?? "media/";
+	const limit = options.limit ?? 50;
+	const result = await bucket.list({
+		prefix,
+		cursor: options.cursor,
+		limit
+	});
+	return {
+		files: (result.objects || []).map((obj) => {
+			const rawKey = obj.key;
+			const name = rawKey.startsWith(prefix) ? rawKey.slice(prefix.length) : rawKey;
+			const cleanedName = name.includes("/") ? name.split("/").pop() : name;
+			const mimeType = obj.httpMetadata?.contentType || guessMimeType(rawKey);
+			let url = "";
+			if (options.publicUrl) url = `${options.publicUrl.endsWith("/") ? options.publicUrl.slice(0, -1) : options.publicUrl}/${rawKey}`;
+			else if (options.apiBasePath) url = `${options.apiBasePath.endsWith("/") ? options.apiBasePath.slice(0, -1) : options.apiBasePath}/${rawKey}`;
+			else url = `/cms/api/media/${rawKey}`;
+			return {
+				key: rawKey,
+				name: cleanedName,
+				size: obj.size,
+				mimeType,
+				uploadedAt: obj.uploaded ? new Date(obj.uploaded).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+				url,
+				etag: obj.etag,
+				customMetadata: obj.customMetadata
+			};
+		}),
+		truncated: result.truncated,
+		cursor: result.cursor
+	};
+}
+/**
+* Uploads a file buffer/stream into R2 Bucket.
+*/
+async function uploadR2File(bucket, file, options = {}) {
+	if (!bucket || typeof bucket.put !== "function") throw new Error("R2 bucket binding is not available in runtime environment.");
+	const prefix = options.prefix ?? "media/";
+	const timestamp = Date.now();
+	const safeName = file.name.replace(/[^a-zA-Z0-9._-]/g, "_");
+	const randomSuffix = Math.random().toString(36).substring(2, 8);
+	const key = options.key ?? `${prefix}${timestamp}-${randomSuffix}/${safeName}`;
+	const arrayBuffer = await file.arrayBuffer();
+	const r2Object = await bucket.put(key, arrayBuffer, {
+		httpMetadata: {
+			contentType: file.type || guessMimeType(safeName),
+			contentDisposition: `inline; filename="${safeName}"`
+		},
+		customMetadata: {
+			originalName: file.name,
+			uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	});
+	let url = "";
+	if (options.publicUrl) url = `${options.publicUrl.endsWith("/") ? options.publicUrl.slice(0, -1) : options.publicUrl}/${key}`;
+	else if (options.apiBasePath) url = `${options.apiBasePath.endsWith("/") ? options.apiBasePath.slice(0, -1) : options.apiBasePath}/${key}`;
+	else url = `/cms/api/media/${key}`;
+	return {
+		key,
+		name: safeName,
+		size: file.size,
+		mimeType: file.type || guessMimeType(safeName),
+		uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		url,
+		etag: r2Object?.etag
+	};
+}
+/**
+* Deletes a file from R2 Bucket by key.
+*/
+async function deleteR2File(bucket, key) {
+	if (!bucket || typeof bucket.delete !== "function") throw new Error("R2 bucket binding is not available in runtime environment.");
+	await bucket.delete(key);
+	return true;
+}
+/**
+* MIME type guesser fallback.
+*/
+function guessMimeType(filename) {
+	switch (filename.split(".").pop()?.toLowerCase()) {
+		case "jpg":
+		case "jpeg": return "image/jpeg";
+		case "png": return "image/png";
+		case "webp": return "image/webp";
+		case "gif": return "image/gif";
+		case "svg": return "image/svg+xml";
+		case "avif": return "image/avif";
+		case "mp4": return "video/mp4";
+		case "webm": return "video/webm";
+		case "mp3": return "audio/mpeg";
+		case "wav": return "audio/wav";
+		case "pdf": return "application/pdf";
+		case "json": return "application/json";
+		case "txt": return "text/plain";
+		case "zip": return "application/zip";
+		default: return "application/octet-stream";
+	}
+}
+//#endregion
+export { deleteR2File, getR2Bucket, listR2Files, r2, uploadR2File };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimelight/cms",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "private": false,
   "description": "Rimelight Entertainment's Content Management System Package",
   "homepage": "https://rimelight.com/docs",
@@ -16,12 +16,31 @@
     "url": "git+https://github.com/Rimelight-Entertainment/rimelight.git"
   },
   "files": [
+    "dist",
     "src"
   ],
   "type": "module",
   "exports": {
-    ".": "./src/index.ts",
-    "./schema": "./src/schema/index.ts",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./schema": {
+      "types": "./dist/schema/index.d.mts",
+      "import": "./dist/schema/index.mjs"
+    },
+    "./schema/sqlite": {
+      "types": "./dist/schema/sqlite.d.mts",
+      "import": "./dist/schema/sqlite.mjs"
+    },
+    "./integration": {
+      "types": "./dist/integration.d.mts",
+      "import": "./dist/integration.mjs"
+    },
+    "./storage": {
+      "types": "./dist/storage/index.d.mts",
+      "import": "./dist/storage/index.mjs"
+    },
     "./core/*": "./src/core/*",
     "./astro/*": "./src/astro/*",
     "./client/styles/*": "./src/client/styles/*",
@@ -34,38 +53,35 @@
     "./auth/*": "./src/auth/*",
     "./cache/*": "./src/cache/*",
     "./search/*": "./src/search/*",
-    "./integration": "./src/integration.ts",
-    "./storage": "./src/storage/index.ts",
     "./admin/*": "./src/admin/*"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@rimelight/i18n": "0.0.6",
-    "@rimelight/ui": "0.0.44",
+    "@rimelight/auth": "0.0.3",
+    "@rimelight/i18n": "0.0.7",
+    "@rimelight/ui": "0.0.46",
     "drizzle-orm": "0.45.2",
     "solid-js": "1.9.15",
     "sortablejs": "1.15.7"
   },
   "devDependencies": {
     "@astrojs/check": "0.9.10",
-    "@rimelight/config": "0.0.3",
+    "@rimelight/config": "0.0.4",
     "@types/sortablejs": "1.15.9",
-    "astro": "7.2.7",
-    "better-auth": "1.7.2",
+    "astro": "7.3.1",
     "typescript": "6.0.3",
-    "unocss": "66.8.1",
-    "vitest": "4.1.11"
+    "unocss": "66.10.0"
   },
   "peerDependencies": {
-    "astro": ">=7.0.0",
-    "better-auth": ">=1.0.0"
+    "astro": ">=7.0.0"
   },
   "engines": {
     "node": ">=26.7.0"
   },
   "scripts": {
+    "build": "vp pack",
     "check": "vp check --fix && astro check"
   }
 }

package/src/admin/api/media.ts

@@ -2,11 +2,20 @@ import type { APIRoute } from "astro"
 import { getR2Bucket, listR2Files, uploadR2File, deleteR2File } from "../../storage/index"
 // @ts-ignore
 import { storageConfig } from "virtual:rimelight-cms/storage"
+// @ts-ignore
+import authAdapter from "virtual:rimelight-cms/auth"
 
 export const prerender = false
 
 export const GET: APIRoute = async ({ request, locals }) => {
   try {
+    const session = await authAdapter.getSession(request)
+    if (!session) {
+      return new Response(JSON.stringify({ success: false, error: "Unauthorized" }), {
+        status: 401,
+        headers: { "Content-Type": "application/json" }
+      })
+    }
     const url = new URL(request.url)
     const prefix = (url.searchParams.get("prefix") ??
       (storageConfig?.prefix as string | undefined) ??
@@ -17,7 +26,7 @@ export const GET: APIRoute = async ({ request, locals }) => {
     const typeFilter = url.searchParams.get("type")?.toLowerCase()
 
     const bindingName = (storageConfig?.binding as string | undefined) ?? "BLOB"
-    const bucket = getR2Bucket(locals, bindingName)
+    const bucket = await getR2Bucket(locals, bindingName)
 
     if (!bucket) {
       return new Response(
@@ -87,8 +96,16 @@ export const GET: APIRoute = async ({ request, locals }) => {
 
 export const POST: APIRoute = async ({ request, locals }) => {
   try {
+    const session = await authAdapter.getSession(request)
+    if (!session) {
+      return new Response(JSON.stringify({ success: false, error: "Unauthorized" }), {
+        status: 401,
+        headers: { "Content-Type": "application/json" }
+      })
+    }
+
     const bindingName = storageConfig?.binding ?? "BLOB"
-    const bucket = getR2Bucket(locals, bindingName)
+    const bucket = await getR2Bucket(locals, bindingName)
 
     if (!bucket) {
       return new Response(
@@ -150,8 +167,16 @@ export const POST: APIRoute = async ({ request, locals }) => {
 
 export const DELETE: APIRoute = async ({ request, locals }) => {
   try {
+    const session = await authAdapter.getSession(request)
+    if (!session) {
+      return new Response(JSON.stringify({ success: false, error: "Unauthorized" }), {
+        status: 401,
+        headers: { "Content-Type": "application/json" }
+      })
+    }
+
     const bindingName = storageConfig?.binding ?? "BLOB"
-    const bucket = getR2Bucket(locals, bindingName)
+    const bucket = await getR2Bucket(locals, bindingName)
 
     if (!bucket) {
       return new Response(

package/src/admin/layouts/CMSDashboardLayout.astro

@@ -1,15 +1,26 @@
 ---
 import ParentLayout from "virtual:rimelight-cms/parent-layout";
+import authAdapter from "virtual:rimelight-cms/auth";
 import RLADashboardGroup from "@rimelight/ui/components/dashboard-group/RLADashboardGroup.astro";
 import RLADashboardSidebar from "@rimelight/ui/components/dashboard-sidebar/RLADashboardSidebar.astro";
 import RLADashboardNavbar from "@rimelight/ui/components/dashboard-navbar/RLADashboardNavbar.astro";
 import RLADashboardPanel from "@rimelight/ui/components/dashboard-panel/RLADashboardPanel.astro";
 import RLADashboardToolbar from "@rimelight/ui/components/dashboard-toolbar/RLADashboardToolbar.astro";
 import RLADashboardSidebarCollapse from "@rimelight/ui/components/dashboard-sidebar-collapse/RLADashboardSidebarCollapse.astro";
+import RLADashboardSidebarToggle from "@rimelight/ui/components/dashboard-sidebar-toggle/RLADashboardSidebarToggle.astro";
 import RLAIcon from "@rimelight/ui/components/icon/RLAIcon.astro";
 import { getRelativeLocaleUrl } from "@rimelight/i18n";
 import "../../client/styles/cms-editor.css";
 
+const session = await authAdapter.getSession(Astro.request);
+if (!session) {
+  if (authAdapter.handleUnauthorized) {
+    const res = await authAdapter.handleUnauthorized(Astro.request);
+    if (res instanceof Response) return res;
+  }
+  return Astro.redirect(getRelativeLocaleUrl(Astro.currentLocale ?? "en", "/auth/sign-in"));
+}
+
 const currentLocale = Astro.currentLocale ?? "en";
 
 const dashboardItem = {
@@ -149,10 +160,12 @@ const {
     </RLADashboardSidebar>
 
     <RLADashboardPanel>
-      <RLADashboardNavbar slot="header" title={title} icon="i-lucide-file-text" style="height: 4rem; min-height: 4rem;">
+      <RLADashboardNavbar slot="header" title={title} icon="i-lucide-file-text" class="h-16 min-h-16">
         <Fragment slot="left">
-          <div class="h-16 min-h-16 flex items-center gap-3" style="height: 4rem; min-height: 4rem; display: flex; align-items: center;">
-            <h1 class="text-xl font-semibold text-highlighted" data-dashboard-navbar-title>{title}</h1>
+          <div class="h-16 min-h-16 flex items-center gap-3">
+            <RLADashboardSidebarToggle class="flex lg:hidden size-9 rounded-lg items-center justify-center border border-default hover:bg-muted text-toned hover:text-highlighted transition-colors shrink-0" />
+            <RLADashboardSidebarCollapse side="left" class="hidden lg:flex size-9 rounded-lg" />
+            <h1 class="text-lg sm:text-xl font-semibold text-highlighted truncate" data-dashboard-navbar-title>{title}</h1>
           </div>
         </Fragment>
         <Fragment slot="right">

package/src/admin/pages/pages-preview.astro

@@ -18,7 +18,7 @@ if (!id) {
 }
 
 const token = Astro.url.searchParams.get("token");
-const secret = process.env.BETTER_AUTH_SECRET || "rimelight-preview-secret-key";
+const secret = process.env.CMS_PREVIEW_SECRET || "rimelight-preview-secret-key";
 if (token) {
   await verifyPreviewToken(id, token, secret);
 }

package/src/astro/PageRenderer.astro

@@ -6,10 +6,10 @@ import BlockRenderer from "./BlockRenderer.astro"
 
 interface Props {
   blocks: BaseBlock[]
-  session?: UserSessionContext
-  locale?: string
-  class?: string
-  components?: Record<string, any>
+  session?: UserSessionContext | undefined
+  locale?: string | undefined
+  class?: string | undefined
+  components?: Record<string, any> | undefined
 }
 
 const {

package/src/env.d.ts

@@ -15,3 +15,9 @@ declare module "virtual:rimelight-cms/db" {
 declare module "virtual:rimelight-cms/storage" {
   export const storageConfig: any
 }
+
+declare module "virtual:rimelight-cms/auth" {
+  import type { AuthAdapter } from "@rimelight/auth"
+  export const authAdapter: AuthAdapter
+  export default authAdapter
+}

package/src/index.ts

@@ -23,11 +23,25 @@ export type {
 export * from "./core/registry.ts"
 export * from "./core/validator.ts"
 
-// Auth & Security Guards
+// Universal Auth & Pluggable Adapters (RFC-0004 & RFC-0006)
 export * from "./auth/permissions.ts"
 export * from "./auth/filter-blocks.ts"
 export * from "./auth/editor-guards.ts"
 export * from "./auth/filter-templates.ts"
+export {
+  cfAccessAuth,
+  auth0Auth,
+  mockAuth,
+  hasRole,
+  hasPermission,
+  evaluateAccess
+} from "@rimelight/auth"
+export type {
+  AuthAdapter as CmsAuthAdapter,
+  AuthAdapter,
+  UserSessionContext,
+  UserType
+} from "@rimelight/auth"
 
 // Edge Cache & Search
 export * from "./cache/purge.ts"
@@ -36,9 +50,8 @@ export * from "./search/query.ts"
 // Database Schemas & Migration
 export * from "./schema/index.ts"
 
-// Astro Components
-export { default as PageRenderer } from "./astro/PageRenderer.astro"
-export { default as BlockRenderer } from "./astro/BlockRenderer.astro"
+// Astro Integration & Components
+export { rimelightCms, type RimelightCmsOptions } from "./integration.ts"
 
 // Toast API
 export * from "./client/toast.ts"