create-nextblock 0.13.1 → 0.13.2

package/templates/nextblock-template/app/cms/components/CortexGlobalAgentChat.tsx

@@ -84,6 +84,9 @@ type CortexAgentStreamEvent =
       message: string;
       type: "error";
     }
+  | {
+      type: "status";
+    }
   | {
       type: "finish";
     };
@@ -92,7 +95,10 @@ const LEGACY_STORAGE_KEY = "nextblock-cortex-global-agent-chat";
 const THREADS_STORAGE_KEY = "nextblock-cortex-global-agent-chat-threads";
 const MAX_STORED_MESSAGES = 40;
 const MAX_STORED_THREADS = 20;
-const REQUEST_TIMEOUT_MS = 90000;
+// Idle timeout: the request is aborted only after this many ms with NO stream
+// activity, so a long multi-section build that keeps streaming tool/text events
+// is not killed at a fixed wall-clock deadline.
+const IDLE_TIMEOUT_MS = 90000;
 const CORTEX_AI_SETTINGS_CHANGED_EVENT = "nextblock:cortex-ai-settings-changed";
 const MUTATING_TOOL_NAMES = new Set([
   "create_cms_page",
@@ -105,6 +111,9 @@ const MUTATING_TOOL_NAMES = new Set([
   "execute_database_mutation",
   "execute_cms_action_plan",
   "insert_content_block",
+  "rewrite_page_draft",
+  "set_content_images",
+  "translate_page",
   "update_cms_item_field",
   "update_current_cms_fields",
   "update_content_block",
@@ -123,6 +132,22 @@ const TOOL_COPY: Record<string, { done: string; running: string }> = {
     done: "Documentation searched",
     running: "Searching documentation...",
   },
+  fetch_url_content: {
+    done: "Website content read",
+    running: "Reading the website...",
+  },
+  rewrite_page_draft: {
+    done: "Draft rewrite staged",
+    running: "Staging a live draft...",
+  },
+  translate_page: {
+    done: "Translation created",
+    running: "Creating the translation...",
+  },
+  set_content_images: {
+    done: "Images updated",
+    running: "Setting images...",
+  },
   create_cms_page: {
     done: "Page created",
     running: "Preparing page...",
@@ -875,23 +900,9 @@ export function CortexGlobalAgentChat() {
   const canSubmit = useMemo(() => input.trim().length > 0 && !isStreaming, [input, isStreaming]);
   const fallbackPageContext = useMemo(() => buildFallbackPageContext(pathname), [pathname]);
   const pageContext = cortexAiPageContext?.pageContext ?? fallbackPageContext;
-  const hasSuccessfulMutationActivity = useMemo(
-    () =>
-      toolActivities.some(
-        (activity) =>
-          activity.status === "success" &&
-          isMutatingToolName(activity.name) &&
-          toolOutputExecutedMutation(activity.output)
-      ),
-    [toolActivities]
-  );
   const visibleToolActivities = useMemo(
     () =>
       toolActivities.filter((activity, index) => {
-        if (hasSuccessfulMutationActivity && activity.status === "error") {
-          return false;
-        }
-
         if (activity.status !== "error") {
           const confirmationKey = getConfirmationKey(activity);
 
@@ -908,11 +919,21 @@ export function CortexGlobalAgentChat() {
           return true;
         }
 
+        // Keep genuine failures visible. Only hide an error when a later retry
+        // of the SAME tool succeeded (a transient error that self-recovered);
+        // do not hide it just because some other, unrelated tool later
+        // succeeded, or a multi-section build would look fully successful even
+        // when individual sections failed.
         return !toolActivities
           .slice(index + 1)
-          .some((nextActivity) => nextActivity.status === "success" && !toolOutputIsNotice(nextActivity.output));
+          .some(
+            (nextActivity) =>
+              nextActivity.name === activity.name &&
+              nextActivity.status === "success" &&
+              !toolOutputIsNotice(nextActivity.output)
+          );
       }),
-    [cancelledConfirmationKeys, hasSuccessfulMutationActivity, toolActivities]
+    [cancelledConfirmationKeys, toolActivities]
   );
 
   const updateThreadMessages = (
@@ -1133,10 +1154,17 @@ export function CortexGlobalAgentChat() {
     }));
     const abortController = new AbortController();
     let timedOut = false;
-    const timeoutId = window.setTimeout(() => {
-      timedOut = true;
-      abortController.abort();
-    }, REQUEST_TIMEOUT_MS);
+    let idleTimeoutId: number | undefined;
+    const armIdleTimeout = () => {
+      if (idleTimeoutId !== undefined) {
+        window.clearTimeout(idleTimeoutId);
+      }
+      idleTimeoutId = window.setTimeout(() => {
+        timedOut = true;
+        abortController.abort();
+      }, IDLE_TIMEOUT_MS);
+    };
+    armIdleTimeout();
 
     if (!threadId) {
       const thread = createChatThread([userMessage, assistantMessage]);
@@ -1206,6 +1234,9 @@ export function CortexGlobalAgentChat() {
           break;
         }
 
+        // Reset the idle timer on every chunk so an actively-streaming build
+        // (many tool + text events) is never aborted mid-flight.
+        armIdleTimeout();
         buffer += decoder.decode(value, { stream: true });
         const frames = buffer.split("\n\n");
         buffer = frames.pop() || "";
@@ -1282,7 +1313,9 @@ export function CortexGlobalAgentChat() {
         )
       );
     } finally {
-      window.clearTimeout(timeoutId);
+      if (idleTimeoutId !== undefined) {
+        window.clearTimeout(idleTimeoutId);
+      }
       if (shouldRefreshAfterMutation && typeof window !== "undefined") {
         // Let client-rendered lists (e.g. the custom blocks library) refetch even
         // though router.refresh() does not re-run their mount-time data fetch.
@@ -1465,6 +1498,13 @@ export function CortexGlobalAgentChat() {
               ))}
             </div>
           )}
+
+          {isStreaming && (
+            <div className="flex items-center gap-2 px-1 text-xs text-slate-500 dark:text-slate-400">
+              <Loader2 className="h-3.5 w-3.5 animate-spin text-primary" />
+              <span>Cortex is working… building a full page can take a little while.</span>
+            </div>
+          )}
         </div>
 
         {streamError && (

package/templates/nextblock-template/app/cms/media/import-external-image.ts

@@ -0,0 +1,289 @@
+// app/cms/media/import-external-image.ts
+"use server";
+
+import "server-only";
+
+import sharp from "sharp";
+import { PutObjectCommand } from "@aws-sdk/client-s3";
+
+import { createClient } from "@nextblock-cms/db/server";
+import { recordMediaUpload } from "@nextblock-cms/db";
+import { getS3Client } from "@nextblock-cms/utils/server";
+
+import { getStorageBackend, getStorageBucket } from "../../../lib/storage/provider";
+import { supabaseUploadObject } from "../../../lib/storage/supabase-storage";
+import { resolveMediaUrl } from "../../../lib/media/resolveMediaUrl";
+
+const MAX_IMPORT_BYTES = 15 * 1024 * 1024; // 15MB
+const IMPORT_TIMEOUT_MS = 15000;
+
+type ImportExternalImageResult =
+  | {
+      success: true;
+      media: {
+        id: string;
+        object_key: string;
+        width: number;
+        height: number;
+        url: string;
+        blur_data_url: string | null;
+        alt_text: string;
+      };
+    }
+  | { error: string };
+
+/**
+ * Reject local/loopback/private/link-local hosts and cloud metadata endpoints so an
+ * admin-supplied URL cannot be used to probe internal infrastructure (SSRF).
+ */
+function isBlockedImportHost(hostname: string): boolean {
+  const host = hostname.trim().toLowerCase().replace(/\.$/, "").replace(/^\[|\]$/g, "");
+
+  if (
+    !host ||
+    host === "localhost" ||
+    host.endsWith(".localhost") ||
+    host.endsWith(".local") ||
+    host.endsWith(".internal") ||
+    host === "metadata.google.internal"
+  ) {
+    return true;
+  }
+
+  if (host === "0.0.0.0" || host === "::1" || host.startsWith("fe80:") || host.startsWith("fc") || host.startsWith("fd")) {
+    return true;
+  }
+
+  const ipv4 = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+
+  if (ipv4) {
+    const a = Number(ipv4[1]);
+    const b = Number(ipv4[2]);
+
+    if (a === 10 || a === 127 || a === 0 || (a === 192 && b === 168) || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function extensionForImage(contentType: string, sharpFormat?: string): string {
+  const format = (sharpFormat || "").toLowerCase();
+  const byFormat: Record<string, string> = { jpeg: "jpg", jpg: "jpg", png: "png", webp: "webp", avif: "avif", gif: "gif", svg: "svg" };
+  if (byFormat[format]) return byFormat[format];
+
+  const ct = contentType.toLowerCase();
+  if (ct.includes("jpeg") || ct.includes("jpg")) return "jpg";
+  if (ct.includes("png")) return "png";
+  if (ct.includes("webp")) return "webp";
+  if (ct.includes("avif")) return "avif";
+  if (ct.includes("gif")) return "gif";
+  if (ct.includes("svg")) return "svg";
+  return "jpg";
+}
+
+function slugifyFileBase(value: string): string {
+  const base = (value || "image")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+  return base || "image";
+}
+
+/**
+ * Download an external image (e.g. an AI-inserted stock photo) and persist it into the
+ * NextBlock media library (R2 or Supabase Storage) so it becomes a permanent, optimized
+ * asset the page no longer hotlinks. ADMIN/WRITER only.
+ */
+export async function importExternalImageToMedia(input: {
+  url: string;
+  altText?: string;
+  fileName?: string;
+}): Promise<ImportExternalImageResult> {
+  const supabase = createClient();
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  if (!user) {
+    return { error: "You must be signed in to import an image." };
+  }
+
+  const { data: profile } = await supabase.from("profiles").select("role").eq("id", user.id).single();
+
+  if (!profile || !["ADMIN", "WRITER"].includes(profile.role)) {
+    return { error: "You do not have permission to import media." };
+  }
+
+  let target: URL;
+
+  try {
+    target = new URL(input.url);
+  } catch {
+    return { error: "That is not a valid URL." };
+  }
+
+  if (target.protocol !== "https:" && target.protocol !== "http:") {
+    return { error: "Only http/https image URLs can be imported." };
+  }
+
+  if (isBlockedImportHost(target.hostname)) {
+    return { error: "Refusing to fetch a local, private, or internal address." };
+  }
+
+  // Unsplash API Guidelines require photos to stay hotlinked to their original
+  // image URL — re-hosting them into our own storage is not permitted. Pexels'
+  // license does allow downloading/hosting, so only Unsplash is blocked here.
+  const importHost = target.hostname.toLowerCase();
+  if (importHost === "unsplash.com" || importHost.endsWith(".unsplash.com")) {
+    return {
+      error:
+        "Unsplash requires photos to stay hotlinked, so they can't be saved into your media library. Keep it as an external image (it still displays fine), or use a Pexels photo or your own upload if you need a stored asset.",
+    };
+  }
+
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), IMPORT_TIMEOUT_MS);
+  let buffer: Buffer;
+  let contentType: string;
+
+  try {
+    const response = await fetch(target.toString(), {
+      headers: { accept: "image/*" },
+      redirect: "follow",
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      return { error: `The image URL responded with HTTP ${response.status}.` };
+    }
+
+    if (isBlockedImportHost(new URL(response.url || target.toString()).hostname)) {
+      return { error: "The image URL redirected to a blocked internal address." };
+    }
+
+    contentType = response.headers.get("content-type") || "";
+
+    if (!/^image\//i.test(contentType)) {
+      return { error: `The URL is not an image (content-type: ${contentType || "unknown"}).` };
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+
+    if (arrayBuffer.byteLength > MAX_IMPORT_BYTES) {
+      return { error: "The image is too large to import (max 15MB)." };
+    }
+
+    buffer = Buffer.from(arrayBuffer);
+  } catch (error) {
+    const aborted = error instanceof Error && /abort/i.test(error.message);
+    return {
+      error: aborted
+        ? "Fetching the image timed out."
+        : `Failed to fetch the image: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  } finally {
+    clearTimeout(timeoutId);
+  }
+
+  let width = 0;
+  let height = 0;
+  let blurDataUrl: string | null = null;
+  let sharpFormat: string | undefined;
+  const isSvg = /svg/i.test(contentType);
+
+  if (!isSvg) {
+    try {
+      const metadata = await sharp(buffer).metadata();
+      width = metadata.width || 0;
+      height = metadata.height || 0;
+      sharpFormat = metadata.format;
+
+      const blurBuffer = await sharp(buffer).resize(16, 16, { fit: "inside" }).webp({ quality: 40 }).toBuffer();
+      blurDataUrl = `data:image/webp;base64,${blurBuffer.toString("base64")}`;
+    } catch {
+      // Non-fatal: proceed without dimensions/blur (e.g. an unusual format sharp can't parse).
+    }
+  }
+
+  const extension = extensionForImage(contentType, sharpFormat);
+  const baseName = slugifyFileBase(
+    input.fileName || input.altText || target.hostname.replace(/^www\./, "").split(".")[0] || "image"
+  );
+  const random = Math.random().toString(36).slice(2, 8);
+  const objectKey = `uploads/${baseName}-${Date.now()}-${random}.${extension}`;
+  const resolvedContentType = contentType || `image/${extension}`;
+
+  try {
+    if (getStorageBackend() === "supabase") {
+      await supabaseUploadObject(objectKey, buffer, resolvedContentType);
+    } else {
+      const s3Client = await getS3Client();
+      const bucket = getStorageBucket();
+
+      if (!s3Client || !bucket) {
+        return { error: "File storage is not configured on this server." };
+      }
+
+      await s3Client.send(
+        new PutObjectCommand({
+          Body: buffer,
+          Bucket: bucket,
+          ContentType: resolvedContentType,
+          Key: objectKey,
+          Metadata: { "uploader-user-id": user.id },
+        })
+      );
+    }
+  } catch (error) {
+    return {
+      error: `Failed to upload the image to storage: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+
+  const publicUrl = resolveMediaUrl(objectKey) ?? "";
+  const fileName = `${baseName}.${extension}`;
+  const altText = (input.altText || baseName.replace(/-/g, " ")).trim();
+  const originalVariant = {
+    fileType: resolvedContentType,
+    height,
+    objectKey,
+    sizeBytes: buffer.byteLength,
+    url: publicUrl,
+    variantLabel: "original",
+    width,
+  };
+
+  const record = await recordMediaUpload(
+    {
+      blurDataUrl: blurDataUrl || undefined,
+      description: altText || undefined,
+      fileName,
+      originalImageDetails: originalVariant,
+      r2OriginalKey: objectKey,
+      r2Variants: [originalVariant],
+    },
+    true
+  );
+
+  if (!record || "error" in record) {
+    return { error: record && "error" in record ? record.error : "Failed to record the imported image." };
+  }
+
+  const media = record.data;
+
+  return {
+    media: {
+      alt_text: (media.description || altText || "").trim(),
+      blur_data_url: media.blur_data_url ?? blurDataUrl,
+      height: media.height || height,
+      id: media.id,
+      object_key: media.object_key,
+      url: publicUrl,
+      width: media.width || width,
+    },
+    success: true,
+  };
+}

package/templates/nextblock-template/app/cms/pages/[id]/edit/EditPageClient.tsx

@@ -4,7 +4,9 @@ import Link from "next/link";
 import React from "react";
 import { Separator } from "@nextblock-cms/ui";
 import { Button } from "@nextblock-cms/ui";
-import { ArrowLeft, Eye, FilePenLine } from "lucide-react";
+import { ViewLiveButton } from "@nextblock-cms/ui";
+import { ArrowLeft, FilePenLine } from "lucide-react";
+import { publishPage } from "../../actions";
 import PageForm from "../../components/PageForm";
 import BlockEditorArea from "../../../blocks/components/BlockEditorArea";
 import ContentLanguageSwitcher from "../../../components/ContentLanguageSwitcher";
@@ -31,6 +33,8 @@ interface EditPageClientProps {
   allSiteLanguages: Language[];
   updatePageAction: (formData: FormData) => Promise<{ error?: string } | void>;
   publicPageUrl: string;
+  isLive: boolean;
+  liveViewUrl: string;
   isDraftModeEnabled: boolean;
   initialFeatureImageUrl?: string | null;
   initialFeatureImageId?: string | null;
@@ -43,6 +47,8 @@ export default function EditPageClient({
   allSiteLanguages,
   updatePageAction,
   publicPageUrl,
+  isLive,
+  liveViewUrl,
   isDraftModeEnabled,
   initialFeatureImageUrl,
   initialFeatureImageId,
@@ -105,15 +111,12 @@ export default function EditPageClient({
                 allSiteLanguages={allSiteLanguages}
               />
             )}
-            <Button variant="outline" asChild>
-              <Link
-                href={publicPageUrl}
-                target="_blank"
-                rel="noopener noreferrer"
-              >
-                <Eye className="mr-2 h-4 w-4" /> View Live
-              </Link>
-            </Button>
+            <ViewLiveButton
+              href={liveViewUrl}
+              isLive={isLive}
+              label="page"
+              publishAction={() => publishPage(pageId)}
+            />
             <Button variant="secondary" asChild>
               <a
                 href={draftModeUrl}

package/templates/nextblock-template/app/cms/pages/[id]/edit/page.tsx

@@ -20,7 +20,7 @@ interface PageWithBlocks extends Page {
   translation_group_id: string;
 }
 
-async function getPageDataWithBlocks(id: number): Promise<{ page: PageWithBlocks; hasDraft: boolean } | null> {
+async function getPageDataWithBlocks(id: number): Promise<{ page: PageWithBlocks; hasDraft: boolean; liveStatus: string; liveSlug: string } | null> {
   const supabase = createClient();
   const { data: pageData, error: pageError } = await supabase
     .from("pages")
@@ -71,7 +71,14 @@ async function getPageDataWithBlocks(id: number): Promise<{ page: PageWithBlocks
     };
   }
 
-  return { page: pageWithBlocks, hasDraft };
+  return {
+    page: pageWithBlocks,
+    hasDraft,
+    // The LIVE row's status/slug (before the draft overlay above) — the "View
+    // Live" button must reflect what is actually published, not the draft.
+    liveStatus: pageData.status as string,
+    liveSlug: pageData.slug as string,
+  };
 }
 
 
@@ -90,13 +97,15 @@ export default async function EditPage(props: { params: Promise<{ id: string }>
 
   const pageDataResult = await getPageDataWithBlocks(pageId);
   if (!pageDataResult) return notFound();
-  const { page: pageWithBlocks, hasDraft } = pageDataResult;
+  const { page: pageWithBlocks, hasDraft, liveStatus, liveSlug } = pageDataResult;
 
   const allSiteLanguages = await getActiveLanguagesServerSide();
 
   const draft = await draftMode();
   const updatePageWithId = updatePage.bind(null, pageId);
   const publicPageUrl = `/${pageWithBlocks.slug}`;
+  const isLive = liveStatus === "published";
+  const liveViewUrl = liveSlug === "home" ? "/" : `/${liveSlug}`;
   let initialFeatureImageUrl: string | null = null;
   let initialFeatureImageId: string | null = null;
 
@@ -123,6 +132,8 @@ export default async function EditPage(props: { params: Promise<{ id: string }>
       allSiteLanguages={allSiteLanguages}
       updatePageAction={updatePageWithId}
       publicPageUrl={publicPageUrl}
+      isLive={isLive}
+      liveViewUrl={liveViewUrl}
       isDraftModeEnabled={draft.isEnabled}
       initialFeatureImageUrl={initialFeatureImageUrl}
       initialFeatureImageId={initialFeatureImageId}

package/templates/nextblock-template/app/cms/pages/actions.ts

@@ -7,6 +7,7 @@ import { redirect } from "next/navigation";
 import type { Database } from "@nextblock-cms/db";
 import { v4 as uuidv4 } from 'uuid';
 import { getOrCreateContentDraft } from "../../../lib/visual-editing/draft-content";
+import { getHomepageTranslationGroupId } from "../../lib/homepage";
 
 type PageStatus = Database['public']['Enums']['page_status'];
 import { encodedRedirect } from "@nextblock-cms/utils/server";
@@ -18,11 +19,16 @@ function getOptionalFeatureImageId(formData: FormData) {
   return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
 }
 
-function revalidatePublicPageSlug(slug: string | null | undefined) {
+function revalidatePublicPageSlug(
+  slug: string | null | undefined,
+  isHomepage = false
+) {
   if (!slug) return;
 
   revalidatePath(`/${slug}`);
-  if (slug === "home" || slug === "accueil") {
+  // Any language variation of the homepage is also served at "/", regardless of
+  // its slug — bust that cache too (the literal-slug check is a cheap fallback).
+  if (isHomepage || slug === "home" || slug === "accueil") {
     revalidatePath("/");
   }
 }
@@ -91,7 +97,11 @@ export async function createPage(formData: FormData) {
   }
 
   revalidatePath("/cms/pages");
-  revalidatePublicPageSlug(newPage?.slug);
+  const createHomepageGroupId = await getHomepageTranslationGroupId(supabase);
+  revalidatePublicPageSlug(
+    newPage?.slug,
+    !!createHomepageGroupId && newPage?.translation_group_id === createHomepageGroupId
+  );
 
   if (newPage?.id) {
     redirect(`/cms/pages/${newPage.id}/edit?success=${encodeURIComponent("Page created successfully.")}`);
@@ -168,9 +178,12 @@ export async function updatePage(pageId: number, formData: FormData) {
   }
 
   revalidatePath("/cms/pages");
-  revalidatePublicPageSlug(existingPage.slug);
+  const updateHomepageGroupId = await getHomepageTranslationGroupId(supabase);
+  const updateIsHomepage =
+    !!updateHomepageGroupId && existingPage.translation_group_id === updateHomepageGroupId;
+  revalidatePublicPageSlug(existingPage.slug, updateIsHomepage);
   if (rawFormData.slug && rawFormData.slug !== existingPage.slug) {
-      revalidatePublicPageSlug(rawFormData.slug);
+      revalidatePublicPageSlug(rawFormData.slug, updateIsHomepage);
   }
 
   revalidatePath(pageEditPath);
@@ -178,6 +191,39 @@ export async function updatePage(pageId: number, formData: FormData) {
 }
 
 
+/**
+ * Publish a page directly (status -> "published") so it becomes visible on the
+ * live site. Used by the draft-aware "View Live" button when an admin chooses to
+ * publish a still-draft page. Revalidates the public surfaces, including "/" when
+ * the page belongs to the homepage translation group.
+ */
+export async function publishPage(pageId: number): Promise<{ error?: string } | void> {
+  const supabase = createClient();
+  const { data: { user } } = await supabase.auth.getUser();
+  if (!user) return { error: "User not authenticated." };
+
+  const { data: page, error } = await supabase
+    .from("pages")
+    .update({ status: "published", updated_at: new Date().toISOString() })
+    .eq("id", pageId)
+    .select("slug, translation_group_id")
+    .single();
+
+  if (error || !page) {
+    return { error: error?.message || "Could not publish the page." };
+  }
+
+  revalidatePath("/cms/pages");
+  revalidatePath(`/cms/pages/${pageId}/edit`);
+  const homepageGroupId = await getHomepageTranslationGroupId(supabase);
+  revalidatePublicPageSlug(
+    page.slug,
+    !!homepageGroupId && page.translation_group_id === homepageGroupId
+  );
+
+  return {};
+}
+
 export async function deletePage(pageId: number) {
   const supabase = createClient();
 
@@ -195,6 +241,13 @@ export async function deletePage(pageId: number) {
 
   const { translation_group_id } = page;
 
+  // Resolve whether this is the homepage BEFORE deleting the group rows — once
+  // the default-language "home" page is gone, the lookup would return null and a
+  // homepage with a non-literal slug wouldn't get "/" revalidated.
+  const deleteHomepageGroupId = await getHomepageTranslationGroupId(supabase);
+  const deleteIsHomepage =
+    !!deleteHomepageGroupId && translation_group_id === deleteHomepageGroupId;
+
   // 2. Find All Related Pages
   const { data: relatedPages, error: relatedPagesError } = await supabase
     .from("pages")
@@ -239,7 +292,7 @@ export async function deletePage(pageId: number) {
   revalidatePath("/cms/navigation");
   if (relatedPages) {
     relatedPages.forEach(p => {
-      revalidatePublicPageSlug(p.slug);
+      revalidatePublicPageSlug(p.slug, deleteIsHomepage);
     });
   }