create-nextblock 0.2.59 → 0.2.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nextblock",
-  "version": "0.2.59",
+  "version": "0.2.62",
   "description": "",
   "main": "index.js",
   "bin": {

package/templates/nextblock-template/app/(auth-pages)/sign-in/page.tsx

@@ -9,6 +9,8 @@ import Link from "next/link";
 import { useTranslations } from "@nextblock-cms/utils";
 import { useSearchParams } from "next/navigation";
 
+import { SandboxCredentialsAlert } from "../../../components/SandboxCredentialsAlert";
+
 function getMessage(searchParams: URLSearchParams): Message | undefined {
     if (searchParams.has('error')) {
         const error = searchParams.get('error');
@@ -31,7 +33,8 @@ export default function Login() {
   const formMessage = getMessage(searchParams);
 
   return (
-    <form className="flex-1 flex flex-col min-w-64 mx-auto">
+    <form className="flex-1 flex flex-col w-full max-w-160 mx-auto">
+      <SandboxCredentialsAlert />
       <h1 className="text-2xl font-medium">{t('sign_in')}</h1>
       <p className="text-sm text-foreground">
         {t('dont_have_account')}{" "}

package/templates/nextblock-template/app/(auth-pages)/sign-up/page.tsx

@@ -9,6 +9,8 @@ import Link from "next/link";
 import { useTranslations } from "@nextblock-cms/utils";
 import { useSearchParams } from "next/navigation";
 
+import { SandboxCredentialsAlert } from "../../../components/SandboxCredentialsAlert";
+
 function getMessage(searchParams: URLSearchParams): Message | undefined {
     if (searchParams.has('error')) {
         const error = searchParams.get('error');
@@ -40,7 +42,8 @@ export default function Signup() {
 
   return (
     <>
-      <form className="flex flex-col min-w-64 max-w-64 mx-auto">
+      <form className="flex flex-col w-full max-w-160 mx-auto">
+        <SandboxCredentialsAlert />
         <h1 className="text-2xl font-medium">{t('sign_up')}</h1>
         <p className="text-sm text text-foreground">
           {t('already_have_account')}{" "}

package/templates/nextblock-template/app/api/cron/reset-sandbox/route.ts

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { createClient } from '@supabase/supabase-js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: NextRequest) {
+  // 1. Guard: Only run in Sandbox Mode
+  if (process.env.NEXT_PUBLIC_IS_SANDBOX !== 'true') {
+    return NextResponse.json({ message: 'Sandbox reset skipped: Not in Sandbox Mode' });
+  }
+
+  // 2. Guard: Verify Cron Secret
+  const authHeader = request.headers.get('authorization');
+  if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
+    return new NextResponse('Unauthorized', {
+      status: 401,
+    });
+  }
+
+  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  const supabaseServiceKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+
+  if (!supabaseUrl || !supabaseServiceKey) {
+    return NextResponse.json({ error: 'Missing Supabase environment variables' }, { status: 500 });
+  }
+
+  const supabase = createClient(supabaseUrl, supabaseServiceKey, {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false,
+    },
+  });
+
+  try {
+    const { error } = await supabase.rpc('reset_sandbox');
+
+    if (error) {
+      console.error('Error resetting sandbox:', error);
+      return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+
+    return NextResponse.json({ success: true, message: 'Sandbox reset successfully' });
+  } catch (err) {
+    console.error('Unexpected error resetting sandbox:', err);
+    return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
+  }
+}

package/templates/nextblock-template/app/cms/blocks/components/BlockEditorModal.tsx

@@ -114,6 +114,7 @@ export function BlockEditorModal({
 
             {/* Editor Area with Contextual Background */}
             <div 
+              onClick={(e) => e.stopPropagation()}
               className={cn(
                   "flex-1 overflow-y-auto p-6",
                   // Conditional Background Logic:

package/templates/nextblock-template/app/cms/revisions/RevisionHistoryButton.tsx

@@ -1,8 +1,9 @@
 // apps/nextblock/app/cms/revisions/RevisionHistoryButton.tsx
 "use client";
 
-import { useEffect, useState, useTransition } from 'react';
+import { useEffect, useState, useTransition, Fragment } from 'react';
 import { Button } from "@nextblock-cms/ui";
+import { cn } from "@nextblock-cms/utils";
 import { Spinner, Alert, AlertDescription } from "@nextblock-cms/ui";
 import {
   Dialog,
@@ -33,49 +34,91 @@ type RevisionItem = {
   author?: { full_name?: string | null; username?: string | null } | null;
 };
 
+import { Input } from "@nextblock-cms/ui";
+
 export default function RevisionHistoryButton({ parentType, parentId }: RevisionHistoryButtonProps) {
   const [open, setOpen] = useState(false);
   const [loading, setLoading] = useState(false);
-  const [revisions, setRevisions] = useState<RevisionItem[] | null>(null);
+  const [revisions, setRevisions] = useState<RevisionItem[]>([]);
   const [currentVersion, setCurrentVersion] = useState<number | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [message, setMessage] = useState<string | null>(null);
   const [isPending, startTransition] = useTransition();
+  const [page, setPage] = useState(1);
+  const [startDate, setStartDate] = useState('');
+  const [endDate, setEndDate] = useState('');
+  
+  const [totalPages, setTotalPages] = useState(0);
+  
   const router = useRouter();
-
   const [compareLoading, setCompareLoading] = useState(false);
   const [activeCompareVersion, setActiveCompareVersion] = useState<number | null>(null);
   const [leftText, setLeftText] = useState<string | null>(null);
   const [rightText, setRightText] = useState<string | null>(null);
-  useEffect(() => {
-    if (!open) return;
+
+  const loadRevisions = async (pageToLoad: number, start?: string, end?: string) => {
     setLoading(true);
     setError(null);
-    (async () => {
-      try {
-        if (parentType === 'page') {
-          const res = await listPageRevisions(parentId);
-        if ('error' in res) {
-          setError(res.error ?? 'Unknown error');
-          setRevisions(null);
-          setCurrentVersion(null);
-        } else {
-          setRevisions(res.revisions as unknown as RevisionItem[]);
-          setCurrentVersion((res as any).currentVersion ?? null);
-        }
-        } else {
-          const res = await listPostRevisions(parentId);
-          if ('error' in res) { setError(res.error ?? 'Unknown error'); setRevisions(null); setCurrentVersion(null); }
-          else { setRevisions(res.revisions as unknown as RevisionItem[]); setCurrentVersion((res as any).currentVersion ?? null); }
-        }
-      } catch (e: unknown) {
-        setError(e instanceof Error ? e.message : 'Failed to load revisions');
-      } finally {
-        setLoading(false);
+    try {
+      let res;
+      // Pass date range to actions
+      if (parentType === 'page') {
+        res = await listPageRevisions(parentId, pageToLoad, start, end);
+      } else {
+        res = await listPostRevisions(parentId, pageToLoad, start, end);
       }
-    })();
+
+      if ('error' in res) {
+        setError(res.error ?? 'Unknown error');
+        setRevisions([]);
+      } else {
+        const newRevisions = res.revisions as unknown as RevisionItem[];
+        setRevisions(newRevisions);
+        setCurrentVersion((res as any).currentVersion ?? null);
+        setTotalPages((res as any).totalPages ?? 0);
+      }
+    } catch (e: unknown) {
+      setError(e instanceof Error ? e.message : 'Failed to load revisions');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    if (!open) return;
+    setRevisions([]);
+    setPage(1);
+    setStartDate('');
+    setEndDate('');
+    loadRevisions(1, '', '');
   }, [open, parentId, parentType]);
 
+  const handlePageChange = (newPage: number) => {
+    setPage(newPage);
+    loadRevisions(newPage, startDate, endDate);
+  };
+
+  const handleStartDateChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const newVal = e.target.value;
+    setStartDate(newVal);
+    setPage(1);
+    loadRevisions(1, newVal, endDate);
+  };
+
+  const handleEndDateChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const newVal = e.target.value;
+    setEndDate(newVal);
+    setPage(1);
+    loadRevisions(1, startDate, newVal);
+  };
+
+  const handleClearDates = () => {
+    setStartDate('');
+    setEndDate('');
+    setPage(1);
+    loadRevisions(1, '', '');
+  };
+
   const handleRestore = (version: number) => {
     setMessage(null);
     setError(null);
@@ -91,9 +134,7 @@ export default function RevisionHistoryButton({ parentType, parentId }: Revision
         }
         setMessage('Version restored successfully.');
         toast.success('Version restored successfully');
-        // refresh current page to fetch restored content
         router.refresh();
-        // Close the dialog after a short delay
         setTimeout(() => setOpen(false), 800);
       } catch (e: unknown) {
         setError(e instanceof Error ? e.message : 'Failed to restore version');
@@ -132,19 +173,41 @@ export default function RevisionHistoryButton({ parentType, parentId }: Revision
   return (
     <Dialog open={open} onOpenChange={setOpen}>
       <Button variant="outline" onClick={() => setOpen(true)}>Revision History</Button>
-      <DialogContent className="max-w-2xl h-[95vh] overflow-y-auto">
+      <DialogContent 
+        className="max-w-2xl h-[95vh] overflow-y-auto flex flex-col"
+        onOpenAutoFocus={(e) => e.preventDefault()}
+      >
         <DialogHeader>
-          <DialogTitle>Revision History</DialogTitle>
+          <div className="flex items-center justify-between mr-8">
+            <DialogTitle>Revision History</DialogTitle>
+            <div className="flex items-center gap-2">
+                 <span className="text-sm text-muted-foreground whitespace-nowrap">From:</span>
+                 <Input 
+                    type="date" 
+                    className="w-auto h-8 text-sm px-2" 
+                    value={startDate} 
+                    onChange={handleStartDateChange} 
+                 />
+                 <span className="text-sm text-muted-foreground whitespace-nowrap">To:</span>
+                 <Input 
+                    type="date" 
+                    className="w-auto h-8 text-sm px-2" 
+                    value={endDate} 
+                    onChange={handleEndDateChange} 
+                 />
+                 {(startDate || endDate) && (
+                   <Button variant="ghost" size="sm" onClick={handleClearDates} className="h-8 px-2 text-xs text-muted-foreground hover:text-foreground">
+                     Clear
+                   </Button>
+                 )}
+            </div>
+          </div>
           <DialogDescription>
             Browse and restore previous versions.
           </DialogDescription>
         </DialogHeader>
-        <div className="space-y-3">
-          {loading && (
-             <div className="flex items-center justify-center py-4">
-                <Spinner size="lg" />
-             </div>
-          )}
+        
+        <div className="flex-1 overflow-y-auto space-y-3 p-1">
           {error && (
             <Alert variant="destructive">
                <AlertDescription>{error}</AlertDescription>
@@ -156,55 +219,146 @@ export default function RevisionHistoryButton({ parentType, parentId }: Revision
             </Alert>
           )}
 
-          {(!loading && revisions && revisions.length === 0) && (
-            <div className="text-sm text-muted-foreground">No revisions yet.</div>
-          )}
-
-              {revisions && revisions.length > 0 && (
-                <div className="divide-y rounded border">
-                  {revisions.map((rev: RevisionItem) => {
+          {revisions && revisions.length > 0 ? (
+            <div className="rounded border divide-y">
+              {revisions.map((rev: RevisionItem, idx) => {
                 const when = rev.created_at ? formatDistanceToNow(new Date(rev.created_at), { addSuffix: true }) : '';
-                const who = rev.author?.full_name || rev.author?.username || rev.author_id || 'Unknown';
+                const authorName = rev.author?.full_name || rev.author?.username;
+                const isCurrent = currentVersion != null && rev.version === currentVersion;
+                const isInitial = rev.version === 1;
+
                 return (
-                  <div key={rev.id} className="flex items-center justify-between gap-4 p-3">
-                    <div className="min-w-0">
-                      <div className="font-medium flex items-center gap-2">
-                        <span>Version {rev.version}</span>
-                        <span className="text-xs text-muted-foreground">({rev.revision_type})</span>
-                        {currentVersion != null && rev.version === currentVersion && (
-                          <span className="text-[10px] px-1.5 py-0.5 rounded bg-blue-50 text-blue-700 border border-blue-200">Current</span>
-                        )}
-                      </div>
-                      <div className="text-xs text-muted-foreground truncate">{when} • {who}</div>
-                    </div>
+                  <Fragment key={`${rev.id}-${idx}`}>
+                    <div className={cn("flex items-center justify-between gap-3 p-3 text-sm", activeCompareVersion === rev.version && "bg-muted/50")}>
+                     <div className="flex flex-col gap-0.5">
+                        <div className="flex items-center gap-2">
+                           <span className="font-semibold text-gray-900">
+                              {isCurrent ? 'Current Version' : (isInitial ? 'Initial Version' : `Version ${rev.version}`)}
+                           </span>
+                           <span className="text-muted-foreground text-xs">• {when}</span>
+                           {authorName && <span className="text-muted-foreground text-xs">• by {authorName}</span>}
+                           {!isCurrent && (
+                              <span className="text-[10px] text-muted-foreground bg-gray-100 px-1 rounded uppercase tracking-wider">{rev.revision_type}</span>
+                           )}
+                           {isInitial && !isCurrent && <span className="text-[10px] px-1.5 py-0.5 rounded bg-gray-100 text-gray-600 border border-gray-200">v1</span>}
+                        </div>
+                     </div>
+
                     <div className="flex gap-2">
-                      <Button variant="secondary" size="sm" onClick={() => handleCompare(rev.version)} disabled={compareLoading && activeCompareVersion === rev.version}>
-                        {compareLoading && activeCompareVersion === rev.version ? <><Spinner className="mr-2 h-3 w-3" /> Loading</> : 'Compare'}
-                      </Button>
-                      <Button size="sm" onClick={() => handleRestore(rev.version)} disabled={isPending}>
-                        {isPending ? <><Spinner className="mr-2 h-3 w-3" /> Restoring</> : 'Restore'}
-                      </Button>
+                      {!isCurrent && (
+                        <>
+                          <Button 
+                            variant="outline" 
+                            size="sm" 
+                            onClick={() => handleCompare(rev.version)} 
+                            disabled={compareLoading && activeCompareVersion === rev.version || (rev as any).has_changes === false} 
+                            className={cn("h-8 px-2 text-xs text-blue-600 border-blue-200 hover:bg-blue-50 hover:text-blue-700", (rev as any).has_changes === false && "invisible pointer-events-none")}
+                          >
+                            {compareLoading && activeCompareVersion === rev.version ? <><Spinner className="mr-1 h-3 w-3" /> compare</> : 'Compare'}
+                          </Button>
+                          <Button 
+                            variant="destructive" 
+                            size="sm" 
+                            onClick={() => handleRestore(rev.version)} 
+                            disabled={isPending || (rev as any).has_changes === false} 
+                            className={cn("h-8 px-2 text-xs", (rev as any).has_changes === false && "invisible pointer-events-none")}
+                          >
+                            {isPending ? <Spinner className="h-3 w-3" /> : 'Restore'}
+                          </Button>
+                        </>
+                      )}
+                      {isCurrent && <span className="text-xs text-muted-foreground italic px-2 self-center">Active</span>}
                     </div>
                   </div>
+                  
+                  {activeCompareVersion === rev.version && (
+                    <div className="p-3 bg-slate-50 border-b relative">
+                      <div className="mb-2 flex items-center justify-between">
+                        <div className="font-semibold text-sm">Comparing Version {activeCompareVersion} to Current</div>
+                        <Button variant="outline" size="sm" onClick={() => { setActiveCompareVersion(null); setLeftText(null); setRightText(null); }} className="h-7 text-xs">Close Compare</Button>
+                      </div>
+                      {compareLoading && <div className="text-sm text-muted-foreground py-4 text-center">Preparing diff…</div>}
+                      {!compareLoading && leftText && rightText && (
+                        <div className="max-h-[50vh] overflow-y-auto border rounded bg-white">
+                           <div className="p-2">
+                              <JsonDiffView
+                                oldValue={leftText}
+                                newValue={rightText}
+                                leftTitle="Current (Now)"
+                                rightTitle={`Version ${activeCompareVersion}`}
+                              />
+                           </div>
+                        </div>
+                      )}
+                    </div>
+                  )}
+                  </Fragment>
                 );
               })}
             </div>
+          ) : (!loading && <div className="text-sm text-muted-foreground text-center py-4">No revisions found for this selection.</div>)}
+
+          {loading && (
+             <div className="flex items-center justify-center py-2">
+                <Spinner size="lg" />
+             </div>
           )}
-          {(activeCompareVersion !== null) && (
-            <div className="mt-4">
-              <div className="mb-2 flex items-center justify-between">
-                <div className="font-semibold">Comparing Version {activeCompareVersion} to Current</div>
-                <Button variant="outline" size="sm" onClick={() => { setActiveCompareVersion(null); setLeftText(null); setRightText(null); }}>Close Compare</Button>
-              </div>
-              {compareLoading && <div className="text-sm text-muted-foreground">Preparing diff…</div>}
-              {!compareLoading && leftText && rightText && (
-                <JsonDiffView
-                  oldValue={leftText}
-                  newValue={rightText}
-                  leftTitle="Current (Now)"
-                  rightTitle={`Version ${activeCompareVersion}`}
-                />
-              )}
+
+          {!loading && (revisions.length > 0 || page > 1) && (
+            <div className="flex items-center justify-center gap-2 py-2 flex-wrap">
+               <Button 
+                 variant="outline" 
+                 size="sm" 
+                 onClick={() => handlePageChange(page - 1)} 
+                 disabled={page <= 1}
+                 className="h-8 px-2"
+               >
+                 Previous
+               </Button>
+               
+               {totalPages > 0 && Array.from({ length: totalPages }, (_, i) => i + 1).map((p) => {
+                  // Show limited pages if too many
+                  if (totalPages > 10) {
+                      if (p === 1 || p === totalPages || (p >= page - 2 && p <= page + 2)) {
+                          return (
+                            <Button
+                                key={p}
+                                variant={p === page ? "default" : "outline"}
+                                size="sm"
+                                onClick={() => handlePageChange(p)}
+                                className="h-8 w-8 p-0"
+                            >
+                                {p}
+                            </Button>
+                          );
+                      } else if (p === page - 3 || p === page + 3) {
+                          return <span key={p} className="text-muted-foreground px-1">...</span>;
+                      }
+                      return null;
+                  }
+                  
+                  return (
+                    <Button
+                        key={p}
+                        variant={p === page ? "default" : "outline"}
+                        size="sm"
+                        onClick={() => handlePageChange(p)}
+                        className="h-8 w-8 p-0"
+                    >
+                        {p}
+                    </Button>
+                  );
+               })}
+
+               <Button 
+                 variant="outline" 
+                 size="sm" 
+                 onClick={() => handlePageChange(page + 1)} 
+                 disabled={page >= totalPages}
+                 className="h-8 px-2"
+               >
+                 Next
+               </Button>
             </div>
           )}
         </div>

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

@@ -4,6 +4,7 @@
 import { createClient } from "@nextblock-cms/db/server";
 import { restorePageToVersion, restorePostToVersion, reconstructPageVersionContent, reconstructPostVersionContent } from './service';
 import { getFullPageContent, getFullPostContent } from './utils';
+import { compare } from 'fast-json-patch';
 
 type RevisionListItem = {
   id: number;
@@ -14,30 +15,230 @@ type RevisionListItem = {
   author?: { full_name?: string | null; username?: string | null } | null;
 };
 
-export async function listPageRevisions(pageId: number) {
+const REVISIONS_PER_PAGE = 10; // Reduced to 10 as requested
+
+export async function listPageRevisions(pageId: number, page = 1, startDate?: string, endDate?: string) {
   const supabase = createClient();
-  const { data, error } = await supabase
+
+  let query = supabase
     .from('page_revisions')
-    .select('id, page_id, author_id, version, revision_type, created_at, author:profiles(full_name, username)')
+    .select('id, page_id, author_id, version, revision_type, created_at, content, author:profiles(full_name, username)', { count: 'exact' })
     .eq('page_id', pageId)
-    .order('version', { ascending: false });
+    .order('version', { ascending: false })
+    .limit(1000); // Fetch up to 1000 recent revisions to allow dense pagination after filtering
+
+  if (startDate) {
+    query = query.gte('created_at', `${startDate}T00:00:00.000Z`);
+  }
+  if (endDate) {
+    query = query.lte('created_at', `${endDate}T23:59:59.999Z`);
+  }
+
+  const { data, error } = await query; // count is less useful now as we filter
+
   if (error) return { error: error.message } as const;
-  const { data: pageRow } = await supabase.from('pages').select('version').eq('id', pageId).single();
+  
+  const { data: pageRow } = await supabase.from('pages').select('version, created_at').eq('id', pageId).single();
   const currentVersion = pageRow?.version ?? null;
-  return { success: true as const, revisions: data as RevisionListItem[], currentVersion };
+  const currentContent = await getFullPageContent(pageId);
+
+  // Map data to include useful flags instead of filtering
+  const allRevisions = (data || []).map((r: any) => {
+    let has_changes = true;
+
+    // 1. Check Diffs
+    if (r.revision_type === 'diff') {
+      let ops = r.content;
+      if (typeof ops === 'string') {
+          try { ops = JSON.parse(ops); } catch { ops = []; }
+      }
+      
+      // Strict check: Diff must be a non-empty array of operations
+      if (!Array.isArray(ops) || ops.length === 0) {
+          has_changes = false;
+      } else {
+        // Check metadata/variant
+        const ignoredSuffixes = ['/updated_at', '/created_at', '/last_modified', '/modified_at', '/version', '/id', '/published_at', '/author_id', '/variant'];
+        const usefulOps = ops.filter((op: any) => {
+            if (!op.path) return true;
+            return !ignoredSuffixes.some(suffix => op.path.endsWith(suffix));
+        });
+        if (usefulOps.length === 0) has_changes = false;
+      }
+    }
+
+    // 2. Check Snapshots
+    if (r.revision_type === 'snapshot' && currentContent && r.version !== currentVersion) {
+        let snapshotContent = r.content;
+        if (typeof snapshotContent === 'string') {
+            try { snapshotContent = JSON.parse(snapshotContent); } catch { /* default true */ }
+        }
+        
+        const ops = compare(currentContent, snapshotContent);
+        
+        const ignoredSuffixes = ['/updated_at', '/created_at', '/last_modified', '/modified_at', '/version', '/id', '/published_at', '/author_id', '/variant'];
+        const usefulOps = ops.filter((op: any) => {
+             if (!op.path) return true;
+             return !ignoredSuffixes.some(suffix => op.path.endsWith(suffix));
+        });
+
+        if (usefulOps.length === 0) has_changes = false;
+    }
+
+    return { ...r, has_changes };
+  }) as (RevisionListItem & { has_changes: boolean; content: any })[];
+
+  // Append Synthetic V1
+  const hasVersion1 = allRevisions.some(r => r.version === 1);
+  const pageCreatedAt = pageRow?.created_at;
+  
+  let matchesDate = true;
+  if (pageCreatedAt) {
+      if (startDate && pageCreatedAt < `${startDate}T00:00:00.000Z`) matchesDate = false;
+      if (endDate && pageCreatedAt > `${endDate}T23:59:59.999Z`) matchesDate = false;
+  }
+  
+  if (!hasVersion1 && (currentVersion ?? 0) > 1 && matchesDate) {
+   allRevisions.push({
+     id: -1,
+     version: 1,
+     revision_type: 'snapshot',
+     created_at: pageCreatedAt ?? new Date().toISOString(),
+     author_id: null,
+     author: { full_name: 'System (Initial)', username: 'system' },
+     has_changes: true, // V1 always counts
+     content: null
+   });
+  }
+  
+  allRevisions.sort((a, b) => b.version - a.version);
+
+  const totalFiltered = allRevisions.length;
+  const totalPages = Math.ceil(totalFiltered / REVISIONS_PER_PAGE);
+  
+  const fromIndex = (page - 1) * REVISIONS_PER_PAGE;
+  // Use map to strip heavy content if not needed, but keep flags
+  const slicedRevisions = allRevisions
+    .slice(fromIndex, fromIndex + REVISIONS_PER_PAGE)
+    .map(({ content, ...rest }) => rest);
+
+  return { 
+      success: true as const, 
+      revisions: slicedRevisions, 
+      currentVersion, 
+      count: totalFiltered, 
+      totalPages, 
+      hasMore: (page * REVISIONS_PER_PAGE) < totalFiltered 
+  };
 }
 
-export async function listPostRevisions(postId: number) {
+export async function listPostRevisions(postId: number, page = 1, startDate?: string, endDate?: string) {
   const supabase = createClient();
-  const { data, error } = await supabase
+
+
+
+  let query = supabase
     .from('post_revisions')
-    .select('id, post_id, author_id, version, revision_type, created_at, author:profiles(full_name, username)')
+    .select('id, post_id, author_id, version, revision_type, created_at, content, author:profiles(full_name, username)', { count: 'exact' })
     .eq('post_id', postId)
-    .order('version', { ascending: false });
+    .order('version', { ascending: false })
+    .limit(1000);
+
+  if (startDate) {
+    query = query.gte('created_at', `${startDate}T00:00:00.000Z`);
+  }
+  if (endDate) {
+    query = query.lte('created_at', `${endDate}T23:59:59.999Z`);
+  }
+
+  const { data, error } = await query;
+
   if (error) return { error: error.message } as const;
-  const { data: postRow } = await supabase.from('posts').select('version').eq('id', postId).single();
+
+  const { data: postRow } = await supabase.from('posts').select('version, created_at').eq('id', postId).single();
   const currentVersion = postRow?.version ?? null;
-  return { success: true as const, revisions: data as RevisionListItem[], currentVersion };
+  const currentContent = await getFullPostContent(postId);
+
+  const allRevisions = (data || []).map((r: any) => {
+    let has_changes = true;
+
+    // 1. Check Diffs
+    if (r.revision_type === 'diff') {
+      let ops = r.content;
+      if (typeof ops === 'string') {
+          try { ops = JSON.parse(ops); } catch { ops = []; }
+      }
+      
+      // Strict check: Diff must be a non-empty array of operations
+      if (!Array.isArray(ops) || ops.length === 0) {
+          has_changes = false;
+      } else {
+        // Check metadata/variant
+        const ignoredSuffixes = ['/updated_at', '/created_at', '/last_modified', '/modified_at', '/version', '/id', '/published_at', '/author_id', '/variant'];
+        const usefulOps = ops.filter((op: any) => {
+            if (!op.path) return true;
+            return !ignoredSuffixes.some(suffix => op.path.endsWith(suffix));
+        });
+        if (usefulOps.length === 0) has_changes = false;
+      }
+    }
+    
+    // 2. Check Snapshots
+    if (r.revision_type === 'snapshot' && currentContent && r.version !== currentVersion) {
+        let snapshotContent = r.content;
+        if (typeof snapshotContent === 'string') {
+            try { snapshotContent = JSON.parse(snapshotContent); } catch { /* default true */ }
+        }
+        
+        const ops = compare(currentContent, snapshotContent);
+        
+        const ignoredSuffixes = ['/updated_at', '/created_at', '/last_modified', '/modified_at', '/version', '/id', '/published_at', '/author_id', '/variant'];
+        const usefulOps = ops.filter((op: any) => {
+             if (!op.path) return true;
+             return !ignoredSuffixes.some(suffix => op.path.endsWith(suffix));
+        });
+
+        if (usefulOps.length === 0) has_changes = false;
+    }
+
+    return { ...r, has_changes };
+  }) as (RevisionListItem & { has_changes: boolean; content: any })[];
+
+  // Synthetic V1
+  const hasVersion1 = allRevisions.some(r => r.version === 1);
+  const postCreatedAt = postRow?.created_at;
+  
+  let matchesDate = true;
+  if (postCreatedAt) {
+      if (startDate && postCreatedAt < `${startDate}T00:00:00.000Z`) matchesDate = false;
+      if (endDate && postCreatedAt > `${endDate}T23:59:59.999Z`) matchesDate = false;
+  }
+
+  if (!hasVersion1 && (currentVersion ?? 0) > 1 && matchesDate) {
+   allRevisions.push({
+     id: -1,
+     version: 1,
+     revision_type: 'snapshot',
+     created_at: postCreatedAt ?? new Date().toISOString(),
+     author_id: null,
+     author: { full_name: 'System (Initial)', username: 'system' },
+     has_changes: true,
+     content: null
+   });
+  }
+
+  allRevisions.sort((a, b) => b.version - a.version);
+
+  const totalFiltered = allRevisions.length;
+  const totalPages = Math.ceil(totalFiltered / REVISIONS_PER_PAGE);
+  
+  const fromIndex = (page - 1) * REVISIONS_PER_PAGE;
+  // Use map to strip heavy content if not needed, but keep flags
+  const slicedRevisions = allRevisions
+    .slice(fromIndex, fromIndex + REVISIONS_PER_PAGE)
+    .map(({ content, ...rest }) => rest);
+
+  return { success: true as const, revisions: slicedRevisions, currentVersion, count: totalFiltered, totalPages, hasMore: (page * REVISIONS_PER_PAGE) < totalFiltered };
 }
 
 export async function restorePageVersion(pageId: number, targetVersion: number) {

package/templates/nextblock-template/app/cms/revisions/service.ts

@@ -28,12 +28,31 @@ export async function createPageRevision(
     .single();
   if (pageError || !page) return { error: 'Page not found' } as const;
 
-  const nextVersion = (page.version ?? 1) + 1;
-  const makeSnapshot = shouldCreateSnapshot(page.version ?? 1) || nextVersion === 2; // ensure early snapshot cadence
+  const currentVersion = page.version ?? 1;
+  const nextVersion = currentVersion + 1;
+
+  // If we are moving to version 2, it means Version 1 was never saved (it was the initial state).
+  // We should save Version 1 now so we have a history base.
+  if (nextVersion === 2) {
+    await supabase.from('page_revisions').insert({
+      page_id: pageId,
+      author_id: authorId, // Can be current author or null
+      version: 1,
+      revision_type: 'snapshot',
+      content: previousContent as unknown as Json,
+    });
+  }
+
+  const makeSnapshot = shouldCreateSnapshot(currentVersion) || nextVersion === 2; // ensure early snapshot cadence
 
   const revisionType: 'snapshot' | 'diff' = makeSnapshot ? 'snapshot' : 'diff';
   const content: Json = makeSnapshot ? (newContent as unknown as Json) : (compare(previousContent, newContent) as unknown as Json);
 
+  // If it's a diff and there are no changes, skip creating revision
+  if (revisionType === 'diff' && Array.isArray(content) && content.length === 0) {
+    return { success: true as const, version: currentVersion }; // Return current version as we didn't bump
+  }
+
   const { error: insertError } = await supabase.from('page_revisions').insert({
     page_id: pageId,
     author_id: authorId,
@@ -67,12 +86,28 @@ export async function createPostRevision(
     .single();
   if (postError || !post) return { error: 'Post not found' } as const;
 
-  const nextVersion = (post.version ?? 1) + 1;
-  const makeSnapshot = shouldCreateSnapshot(post.version ?? 1) || nextVersion === 2;
+  const currentVersion = post.version ?? 1;
+  const nextVersion = currentVersion + 1;
+
+  if (nextVersion === 2) {
+    await supabase.from('post_revisions').insert({
+      post_id: postId,
+      author_id: authorId,
+      version: 1,
+      revision_type: 'snapshot',
+      content: previousContent as unknown as Json,
+    });
+  }
+
+  const makeSnapshot = shouldCreateSnapshot(currentVersion) || nextVersion === 2;
 
   const revisionType: 'snapshot' | 'diff' = makeSnapshot ? 'snapshot' : 'diff';
   const content: Json = makeSnapshot ? (newContent as unknown as Json) : (compare(previousContent, newContent) as unknown as Json);
 
+  if (revisionType === 'diff' && Array.isArray(content) && content.length === 0) {
+    return { success: true as const, version: currentVersion };
+  }
+
   const { error: insertError } = await supabase.from('post_revisions').insert({
     post_id: postId,
     author_id: authorId,
@@ -104,27 +139,50 @@ export async function restorePageToVersion(pageId: number, targetVersion: number
     .order('version', { ascending: false })
     .limit(1)
     .maybeSingle();
-  if (snapshotError || !snapshot) return { error: 'No snapshot found at or before target version.' } as const;
-
-  let content = snapshot.content as unknown as FullPageContent;
 
-  // 2. Fetch diffs up to target and apply
-  const { data: diffs, error: diffsError } = await supabase
-    .from('page_revisions')
-    .select('version, content, revision_type')
-    .eq('page_id', pageId)
-    .gt('version', snapshot.version)
-    .lte('version', targetVersion)
-    .order('version', { ascending: true });
-  if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
+  let content: FullPageContent;
+  let baseVersion = 0;
+
+  if (snapshot) {
+    content = snapshot.content as unknown as FullPageContent;
+    baseVersion = snapshot.version;
+  } else if (targetVersion === 1) {
+    // Fallback for missing Version 1: use empty content with current meta
+    const { data: pageMeta } = await supabase
+      .from('pages')
+      .select('title, slug, language_id, status, meta_title, meta_description')
+      .eq('id', pageId)
+      .single();
+    if (!pageMeta) return { error: 'Page not found.' } as const;
+    content = {
+      meta: pageMeta,
+      blocks: [],
+    };
+    baseVersion = 1;
+  } else {
+    if (snapshotError) return { error: `Snapshot error: ${snapshotError.message}` } as const;
+    return { error: 'No snapshot found at or before target version.' } as const;
+  }
 
-  for (const r of diffs || []) {
-    if (r.revision_type === 'diff') {
-      const ops = r.content as any[];
-      const result = applyPatch(content as any, ops, /*validate*/ false, /*mutateDocument*/ true);
-      content = result.newDocument as unknown as FullPageContent;
-    } else {
-      content = r.content as unknown as FullPageContent;
+  // 2. Fetch diffs up to target and apply (only if we are not already at target)
+  if (baseVersion < targetVersion) {
+    const { data: diffs, error: diffsError } = await supabase
+      .from('page_revisions')
+      .select('version, content, revision_type')
+      .eq('page_id', pageId)
+      .gt('version', baseVersion)
+      .lte('version', targetVersion)
+      .order('version', { ascending: true });
+    if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
+
+    for (const r of diffs || []) {
+      if (r.revision_type === 'diff') {
+        const ops = r.content as any[];
+        const result = applyPatch(content as any, ops, /*validate*/ false, /*mutateDocument*/ true);
+        content = result.newDocument as unknown as FullPageContent;
+      } else {
+        content = r.content as unknown as FullPageContent;
+      }
     }
   }
 
@@ -193,17 +251,38 @@ export async function restorePostToVersion(postId: number, targetVersion: number
     .order('version', { ascending: false })
     .limit(1)
     .maybeSingle();
-  if (snapshotError || !snapshot) return { error: 'No snapshot found at or before target version.' } as const;
 
-  let content = snapshot.content as unknown as FullPostContent;
+  let content: FullPostContent;
+  let baseVersion = 0;
+
+  if (snapshot) {
+    content = snapshot.content as unknown as FullPostContent;
+    baseVersion = snapshot.version;
+  } else if (targetVersion === 1) {
+    const { data: postMeta } = await supabase
+      .from('posts')
+      .select('title, slug, language_id, status, meta_title, meta_description, excerpt, published_at, feature_image_id')
+      .eq('id', postId)
+      .single();
+    if (!postMeta) return { error: 'Post not found.' } as const;
+    content = {
+      meta: postMeta,
+      blocks: [],
+    };
+    baseVersion = 1;
+  } else {
+    if (snapshotError) return { error: `Snapshot error: ${snapshotError.message}` } as const;
+    return { error: 'No snapshot found at or before target version.' } as const;
+  }
 
-  const { data: diffs, error: diffsError } = await supabase
-    .from('post_revisions')
-    .select('version, content, revision_type')
-    .eq('post_id', postId)
-    .gt('version', snapshot.version)
-    .lte('version', targetVersion)
-    .order('version', { ascending: true });
+  if (baseVersion < targetVersion) {
+    const { data: diffs, error: diffsError } = await supabase
+      .from('post_revisions')
+      .select('version, content, revision_type')
+      .eq('post_id', postId)
+      .gt('version', baseVersion)
+      .lte('version', targetVersion)
+      .order('version', { ascending: true });
   if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
 
   for (const r of diffs || []) {
@@ -214,6 +293,7 @@ export async function restorePostToVersion(postId: number, targetVersion: number
     } else {
       content = r.content as unknown as FullPostContent;
     }
+    }
   }
 
   // Determine next version for post
@@ -281,17 +361,38 @@ export async function reconstructPageVersionContent(pageId: number, targetVersio
     .order('version', { ascending: false })
     .limit(1)
     .maybeSingle();
-  if (snapshotError || !snapshot) return { error: 'No snapshot found at or before target version.' } as const;
 
-  let content = snapshot.content as unknown as FullPageContent;
+  let content: FullPageContent;
+  let baseVersion = 0;
+
+  if (snapshot) {
+    content = snapshot.content as unknown as FullPageContent;
+    baseVersion = snapshot.version;
+  } else if (targetVersion === 1) {
+    const { data: pageMeta } = await supabase
+      .from('pages')
+      .select('title, slug, language_id, status, meta_title, meta_description')
+      .eq('id', pageId)
+      .single();
+    if (!pageMeta) return { error: 'Page not found.' } as const;
+    content = {
+      meta: pageMeta,
+      blocks: [],
+    };
+    baseVersion = 1;
+  } else {
+    if (snapshotError) return { error: `Snapshot error: ${snapshotError.message}` } as const;
+    return { error: 'No snapshot found at or before target version.' } as const;
+  }
 
-  const { data: diffs, error: diffsError } = await supabase
-    .from('page_revisions')
-    .select('version, content, revision_type')
-    .eq('page_id', pageId)
-    .gt('version', snapshot.version)
-    .lte('version', targetVersion)
-    .order('version', { ascending: true });
+  if (baseVersion < targetVersion) {
+    const { data: diffs, error: diffsError } = await supabase
+      .from('page_revisions')
+      .select('version, content, revision_type')
+      .eq('page_id', pageId)
+      .gt('version', baseVersion)
+      .lte('version', targetVersion)
+      .order('version', { ascending: true });
   if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
 
   for (const r of diffs || []) {
@@ -303,6 +404,7 @@ export async function reconstructPageVersionContent(pageId: number, targetVersio
       content = r.content as unknown as FullPageContent;
     }
   }
+  }
   return { success: true as const, content };
 }
 
@@ -318,17 +420,38 @@ export async function reconstructPostVersionContent(postId: number, targetVersio
     .order('version', { ascending: false })
     .limit(1)
     .maybeSingle();
-  if (snapshotError || !snapshot) return { error: 'No snapshot found at or before target version.' } as const;
 
-  let content = snapshot.content as unknown as FullPostContent;
+  let content: FullPostContent;
+  let baseVersion = 0;
+
+  if (snapshot) {
+    content = snapshot.content as unknown as FullPostContent;
+    baseVersion = snapshot.version;
+  } else if (targetVersion === 1) {
+    const { data: postMeta } = await supabase
+      .from('posts')
+      .select('title, slug, language_id, status, meta_title, meta_description, excerpt, published_at, feature_image_id')
+      .eq('id', postId)
+      .single();
+    if (!postMeta) return { error: 'Post not found.' } as const;
+    content = {
+      meta: postMeta,
+      blocks: [],
+    };
+    baseVersion = 1;
+  } else {
+    if (snapshotError) return { error: `Snapshot error: ${snapshotError.message}` } as const;
+    return { error: 'No snapshot found at or before target version.' } as const;
+  }
 
-  const { data: diffs, error: diffsError } = await supabase
-    .from('post_revisions')
-    .select('version, content, revision_type')
-    .eq('post_id', postId)
-    .gt('version', snapshot.version)
-    .lte('version', targetVersion)
-    .order('version', { ascending: true });
+  if (baseVersion < targetVersion) {
+    const { data: diffs, error: diffsError } = await supabase
+      .from('post_revisions')
+      .select('version, content, revision_type')
+      .eq('post_id', postId)
+      .gt('version', baseVersion)
+      .lte('version', targetVersion)
+      .order('version', { ascending: true });
   if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
 
   for (const r of diffs || []) {
@@ -340,5 +463,6 @@ export async function reconstructPostVersionContent(postId: number, targetVersio
       content = r.content as unknown as FullPostContent;
     }
   }
+  }
   return { success: true as const, content };
 }

package/templates/nextblock-template/app/layout.tsx

@@ -2,6 +2,8 @@ import '@nextblock-cms/ui/styles/globals.css';
 import '@nextblock-cms/editor/styles/editor.css';
 // app/layout.tsx
 import { EnvVarWarning } from "@/components/env-var-warning";
+import { SandboxBanner } from "@/components/SandboxBanner";
+import { Analytics } from "@vercel/analytics/next"
 import { ThemeSwitcher } from '@/components/theme-switcher';
 import type { Metadata } from 'next';
 import Header from "@/components/Header";
@@ -172,6 +174,7 @@ export default async function RootLayout({
         <link rel="dns-prefetch" href="https://db.ppcppwsfnrptznvbxnsz.supabase.co" />
         <link rel="dns-prefetch" href="https://realtime.supabase.com" />
         <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <Analytics/>
       </head>
       <body className="bg-background text-foreground min-h-screen flex flex-col">
         <Providers
@@ -183,6 +186,7 @@ export default async function RootLayout({
           translations={translations}
           nonce={nonce}
         >
+          {process.env.NEXT_PUBLIC_IS_SANDBOX === 'true' && <SandboxBanner />}
           <ToasterProvider />
           <div className="flex-1 w-full flex flex-col items-center">
             <nav className="w-full flex justify-center border-b border-b-foreground/10 h-16">

package/templates/nextblock-template/components/SandboxBanner.tsx

@@ -0,0 +1,17 @@
+'use client';
+
+import { TriangleAlert } from 'lucide-react';
+import { useTranslations } from '@nextblock-cms/utils';
+
+export function SandboxBanner() {
+  const { t } = useTranslations();
+  
+  return (
+    <div className="w-full z-[100] bg-amber-500 text-amber-950 px-4 py-2 text-center text-sm font-medium shadow-md flex items-center justify-center gap-2">
+      <TriangleAlert className="w-4 h-4" />
+      <span>
+        {t('sandbox_mode_banner')}
+      </span>
+    </div>
+  );
+}

package/templates/nextblock-template/components/SandboxCredentialsAlert.tsx

@@ -0,0 +1,29 @@
+'use client';
+
+import { Info } from 'lucide-react';
+import { useTranslations } from '@nextblock-cms/utils';
+
+export function SandboxCredentialsAlert() {
+  const { t } = useTranslations();
+
+  // Only show in sandbox mode
+  if (process.env.NEXT_PUBLIC_IS_SANDBOX !== 'true') {
+    return null;
+  }
+
+  return (
+    <div className="bg-blue-50 dark:bg-blue-950/30 border border-blue-200 dark:border-blue-800 rounded-lg p-4 mt-6 flex items-start gap-3 text-sm">
+      <Info className="w-5 h-5 text-blue-600 dark:text-blue-400 shrink-0 mt-0.5" />
+      <div className="text-blue-900 dark:text-blue-100">
+        <p className="font-semibold mb-1">{t('demo_access_title')}</p>
+        <p className="mb-2">
+          {t('demo_access_desc')}
+        </p>
+        <ul className="space-y-1 font-mono text-xs bg-white/50 dark:bg-black/20 p-2 rounded border border-blue-100 dark:border-blue-900/50">
+          <li>{t('demo_user_label')} <span className="font-bold select-all">demo@nextblock.ca</span></li>
+          <li>{t('demo_password_label')} <span className="font-bold select-all">password</span></li>
+        </ul>
+      </div>
+    </div>
+  );
+}

package/templates/nextblock-template/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@nextblock-cms/template",
-  "version": "0.2.37",
+  "version": "0.2.40",
   "private": true,
   "scripts": {
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
-    "lint": "next lint"
+    "lint": "next lint",
+    "deploy:supabase": "node tools/deploy-supabase.js"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.920.0",

package/templates/nextblock-template/proxy.ts

@@ -214,13 +214,13 @@ export default async function proxy(request: NextRequest) {
 
       const csp = [
         "default-src 'self'",
-        `script-src 'self' blob: data: 'nonce-${nonceValue}'`,
-        "style-src 'self' 'unsafe-inline'",
-        `img-src 'self' data: blob:${r2Hostnames}`,
-        "font-src 'self'",
+        `script-src 'self' blob: data: 'nonce-${nonceValue}' https://vercel.live https://vercel.com`,
+        "style-src 'self' 'unsafe-inline' https://vercel.live https://vercel.com",
+        `img-src 'self' data: blob:${r2Hostnames} https://vercel.live https://vercel.com`,
+        "font-src 'self' https://vercel.live https://assets.vercel.com",
         "object-src 'none'",
-        `connect-src 'self' https://${supabaseHostname} wss://${supabaseHostname}${r2Hostnames}`,
-        "frame-src 'self' blob: data: https://www.youtube.com",
+        `connect-src 'self' https://${supabaseHostname} wss://${supabaseHostname}${r2Hostnames} https://vercel.live https://vercel.com`,
+        "frame-src 'self' blob: data: https://www.youtube.com https://vercel.live https://vercel.com",
         "form-action 'self'",
         "base-uri 'self'",
       ].join('; ');

package/templates/nextblock-template/tools/deploy-supabase.js

@@ -0,0 +1,161 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Colors for console output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+};
+
+function getDbPassword() {
+  if (process.env.SUPABASE_DB_PASSWORD) {
+    return process.env.SUPABASE_DB_PASSWORD;
+  }
+  if (process.env.POSTGRES_URL) {
+    try {
+      const url = new URL(process.env.POSTGRES_URL);
+      return url.password;
+    } catch (e) {
+      return null;
+    }
+  }
+  return null;
+}
+
+function checkEnv() {
+  const missing = [];
+
+  if (!process.env.SUPABASE_ACCESS_TOKEN) {
+    missing.push('SUPABASE_ACCESS_TOKEN');
+  }
+  if (!process.env.SUPABASE_PROJECT_ID) {
+    missing.push('SUPABASE_PROJECT_ID');
+  }
+  if (!process.env.NEXT_PUBLIC_URL) {
+    missing.push('NEXT_PUBLIC_URL');
+  }
+
+  const dbPassword = getDbPassword();
+  if (!dbPassword) {
+    missing.push('SUPABASE_DB_PASSWORD (or POSTGRES_URL)');
+  }
+
+  if (missing.length > 0) {
+    console.log(
+      `${colors.yellow}⚠️  Skipping Supabase deployment: Missing environment variables: ${missing.join(', ')}${colors.reset}`,
+    );
+    console.log(
+      `${colors.yellow}   This is expected for Pull Requests or forks without secrets configured.${colors.reset}`,
+    );
+    return false;
+  }
+  return true;
+}
+
+function runCommand(command) {
+  try {
+    console.log(`${colors.blue}Running: ${command}${colors.reset}`);
+    execSync(command, { stdio: 'inherit' });
+  } catch (error) {
+    console.error(`${colors.red}❌ Command failed: ${command}${colors.reset}`);
+    process.exit(1);
+  }
+}
+
+async function deploy() {
+  console.log(
+    `${colors.green}🚀 Starting Supabase Deployment...${colors.reset}`,
+  );
+
+  if (!checkEnv()) {
+    process.exit(0);
+  }
+
+  const dbPassword = getDbPassword();
+  if (!dbPassword) {
+    console.error(
+      `${colors.red}❌ Could not determine database password.${colors.reset}`,
+    );
+    process.exit(1);
+  }
+
+  // Detect Supabase location
+  // 1. Monorepo Dev (apps/nextblock -> libs/db/src)
+  // 2. Standalone (root -> supabase)
+  let workDirFlag = '';
+
+  // Check if we are in monorepo structure relative to this script
+  // Script is in apps/nextblock/tools/deploy-supabase.js
+  // So monorepo root is ../../../
+  // libs/db/src is ../../../libs/db/src
+
+  // More robust check: check if libs/db/src/supabase/config.toml exists
+  // We assume the command is run from the project root (process.cwd())
+
+  // If running from apps/nextblock root (monorepo dev)
+  const monorepoDbPath = path.join(
+    process.cwd(),
+    '../../libs/db/src/supabase/config.toml',
+  );
+
+  // If running from workspace root (standalone)
+  const standaloneDbPath = path.join(process.cwd(), 'supabase/config.toml');
+
+  if (fs.existsSync(monorepoDbPath)) {
+    console.log(
+      `${colors.blue}ℹ️  Detected Monorepo environment (libs/db/src)${colors.reset}`,
+    );
+    workDirFlag = '--workdir ../../libs/db/src';
+  } else if (fs.existsSync(standaloneDbPath)) {
+    console.log(
+      `${colors.blue}ℹ️  Detected Standalone environment (./supabase)${colors.reset}`,
+    );
+    workDirFlag = '';
+  } else {
+    // Fallback or maybe we are running from root of monorepo?
+    const rootDbPath = path.join(
+      process.cwd(),
+      'libs/db/src/supabase/config.toml',
+    );
+    if (fs.existsSync(rootDbPath)) {
+      workDirFlag = '--workdir libs/db/src';
+    }
+  }
+
+  console.log(
+    `${colors.green}🔗 Linking to Supabase project...${colors.reset}`,
+  );
+  runCommand(
+    `npx supabase link --project-ref ${process.env.SUPABASE_PROJECT_ID} --password ${dbPassword} ${workDirFlag}`,
+  );
+
+  console.log(
+    `${colors.green}📦 Pushing database migrations...${colors.reset}`,
+  );
+  runCommand(`npx supabase db push --include-all ${workDirFlag}`, {
+    stdio: 'inherit',
+  }); // db push input 'y' handled?
+  // npx supabase db push usually asks for confirmation if destructive. --include-all might implies force? using input 'y' might be safer or --force if avail.
+  // Actually, CI usually needs --no-interactive or equivalent if prompts exist.
+  // But our previous script used just db push without input 'y' and relied on process.stdin or just worked.
+  // Wait, in create-nextblock.js we piped 'y\n'.
+  // In deploy-supabase.js we are using inherit stdio, so it might prompt if strictly necessary, but usually db push to remote is fine unless destructive.
+  // However, I previously wrote `npx supabase db push ...` and it seemed fine.
+
+  // Re-reading previous script: runCommand used `execSync(command, { stdio: 'inherit' });`
+
+  // Let's stick to the previous working command.
+
+  console.log(
+    `${colors.green}⚙️  Pushing Supabase config (Site URL: ${process.env.NEXT_PUBLIC_URL})...${colors.reset}`,
+  );
+  runCommand(`npx supabase config push ${workDirFlag}`);
+
+  console.log(`${colors.green}✅ Supabase deployment complete!${colors.reset}`);
+}
+
+deploy();