create-nextblock 0.14.4 → 0.14.6

package/templates/nextblock-template/app/api/mcp/route.ts

@@ -0,0 +1,346 @@
+import { revalidatePath } from 'next/cache';
+
+import {
+  createClient,
+  getServiceRoleSupabaseClient,
+  verifyPackageOnline,
+} from '@nextblock-cms/db/server';
+import {
+  CORTEX_AI_PACKAGE_ID,
+  handleCortexMcpMessage,
+  isLocalhostHost,
+  parseBearerToken,
+  resolveCortexAiMcpSettings,
+  shouldTrustLocalMcpRequest,
+  touchCortexAiMcpToken,
+  verifyCortexAiMcpToken,
+  type CortexAiMcpScope,
+  type CortexMcpToolContext,
+  type JsonRpcMessage,
+} from '@nextblock-cms/cortex';
+
+import { validateBlockContent } from '../../../lib/blocks/blockRegistry';
+import { importExternalImageToMedia } from '../../cms/media/import-external-image';
+import { captureRevisionBaseline, commitRevisionFromBaseline } from '../../cms/revisions/service';
+import type { AnyFullContent } from '../../cms/revisions/utils';
+
+/**
+ * Model Context Protocol server endpoint.
+ *
+ * Exposes the Cortex AI tool registry over MCP Streamable HTTP so external clients
+ * (Claude Code, Claude Desktop, Cursor, VS Code) can operate this CMS with the same
+ * typed, validated tools the in-app dashboard agent uses. The protocol itself lives
+ * in `@nextblock-cms/cortex` (`mcp-server.ts`); this file is the HTTP shim plus auth.
+ *
+ * Node runtime, not Edge: the tool executors reach `node:crypto`, `sharp` (via the
+ * media importer) and the service-role Supabase client.
+ */
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+const SERVER_VERSION = '1.0.0';
+
+/**
+ * Confirmation is skipped for MCP callers, deliberately.
+ *
+ * The in-app agent's two-phase confirm works by matching a phrase in the user's *next
+ * chat message*, which has no analogue in MCP — the model calls a tool and gets a
+ * result, with no channel to carry a human phrase back. Every MCP host already gates
+ * tool calls behind its own approval UI, so the confirmation would be a second prompt
+ * the protocol cannot satisfy, and leaving it on would simply make every mutating
+ * tool return a preview forever. The real control for MCP is the token scope: a
+ * read-only token never sees a mutating tool at all.
+ */
+const MCP_SKIP_CONFIRMATION = true;
+
+type McpAuth = {
+  actorUserId: string | null;
+  scopes: CortexAiMcpScope[];
+  source: 'admin-session' | 'localhost' | 'token';
+};
+
+async function importExternalImageForMcp(input: {
+  url: string;
+  altText?: string;
+}): Promise<{ id: string } | { error: string }> {
+  const result = await importExternalImageToMedia({ altText: input.altText, url: input.url });
+
+  if ('error' in result) {
+    return { error: result.error };
+  }
+
+  return { id: result.media.id };
+}
+
+/** Mirrors the global-agent route so MCP writes land in Revision History like any other edit. */
+function createMcpRevisionRecorder(authorId: string | null) {
+  return async function recordRevision(input: {
+    baseline?: unknown;
+    contentType: 'page' | 'post' | 'product';
+    entityId: number | string;
+    phase: 'capture' | 'commit';
+  }): Promise<unknown> {
+    if (input.phase === 'capture') {
+      return captureRevisionBaseline(input.contentType, input.entityId);
+    }
+
+    const result = await commitRevisionFromBaseline(
+      input.contentType,
+      input.entityId,
+      authorId,
+      (input.baseline ?? null) as AnyFullContent | null
+    );
+
+    if ('error' in result) {
+      console.error('Cortex AI MCP: revision not recorded —', result.error);
+    }
+
+    return undefined;
+  };
+}
+
+/**
+ * Reject cross-origin browser calls (DNS-rebinding defence, required by the spec).
+ *
+ * Only enforced when an `Origin` header is present: native MCP clients are not
+ * browsers and send none, so requiring one would lock out every real caller.
+ */
+function isOriginAllowed(request: Request): boolean {
+  const origin = request.headers.get('origin');
+
+  if (!origin) {
+    return true;
+  }
+
+  let originHost: string;
+
+  try {
+    originHost = new URL(origin).host;
+  } catch {
+    return false;
+  }
+
+  if (isLocalhostHost(originHost)) {
+    return true;
+  }
+
+  const host = request.headers.get('host');
+
+  if (host && originHost.toLowerCase() === host.toLowerCase()) {
+    return true;
+  }
+
+  const configuredUrl = process.env.NEXT_PUBLIC_URL;
+
+  if (configuredUrl) {
+    try {
+      return new URL(configuredUrl).host.toLowerCase() === originHost.toLowerCase();
+    } catch {
+      return false;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Establish who is calling.
+ *
+ * Three accepted paths, in priority order:
+ *  1. A bearer token from `mcp_access_tokens` — the path every external client uses.
+ *  2. An authenticated ADMIN cookie session — lets the dashboard's own "Test
+ *     connection" button reach the endpoint without minting a token first.
+ *  3. Loopback in development, when the operator has left that setting on.
+ */
+async function authenticateMcpRequest(request: Request): Promise<McpAuth | null> {
+  const serviceClient = getServiceRoleSupabaseClient();
+  const settings = await resolveCortexAiMcpSettings(serviceClient);
+
+  if (!settings.enabled) {
+    return null;
+  }
+
+  const bearer = parseBearerToken(request.headers.get('authorization'));
+
+  if (bearer) {
+    const verification = await verifyCortexAiMcpToken(serviceClient, bearer);
+
+    if (!verification.valid) {
+      return null;
+    }
+
+    // Bookkeeping only — never block the call on it.
+    void touchCortexAiMcpToken(serviceClient, verification.token.id);
+
+    return {
+      actorUserId: verification.token.created_by,
+      scopes: verification.scopes,
+      source: 'token',
+    };
+  }
+
+  const adminUserId = await resolveAdminSessionUserId();
+
+  if (adminUserId) {
+    return { actorUserId: adminUserId, scopes: ['read', 'write'], source: 'admin-session' };
+  }
+
+  if (shouldTrustLocalMcpRequest({ hostHeader: request.headers.get('host'), settings })) {
+    return { actorUserId: null, scopes: ['read', 'write'], source: 'localhost' };
+  }
+
+  return null;
+}
+
+async function resolveAdminSessionUserId(): Promise<string | null> {
+  try {
+    const supabase = createClient();
+    const {
+      data: { user },
+    } = await supabase.auth.getUser();
+
+    if (!user) {
+      return null;
+    }
+
+    const { data: profile } = await supabase
+      .from('profiles')
+      .select('role')
+      .eq('id', user.id)
+      .single();
+
+    return profile?.role === 'ADMIN' ? user.id : null;
+  } catch {
+    return null;
+  }
+}
+
+function buildToolContext(auth: McpAuth): CortexMcpToolContext {
+  return {
+    actorUserId: auth.actorUserId,
+    importExternalImage: importExternalImageForMcp,
+    // No open editor over MCP: tools that need a target take it in their arguments
+    // (`cmsTarget`, `slug`, `entityId`) rather than inheriting one from a UI.
+    pageContext: null,
+    recordRevision: createMcpRevisionRecorder(auth.actorUserId),
+    revalidatePath,
+    skipConfirmation: MCP_SKIP_CONFIRMATION,
+    supabase: getServiceRoleSupabaseClient(),
+    validateBlockContent,
+  };
+}
+
+const JSON_HEADERS = {
+  'Cache-Control': 'no-store',
+  'Content-Type': 'application/json; charset=utf-8',
+} as const;
+
+/**
+ * 401 for an unauthenticated caller.
+ *
+ * The `WWW-Authenticate` value is intentionally bare. Adding a `resource_metadata`
+ * parameter would advertise RFC 9728 OAuth discovery, and Claude Code responds to
+ * that by starting an OAuth flow — which dead-ends against a static-token server.
+ * A plain challenge tells the client "send a bearer token" and nothing more.
+ */
+function unauthorized(message: string): Response {
+  return new Response(JSON.stringify({ error: message }), {
+    headers: {
+      ...JSON_HEADERS,
+      'WWW-Authenticate': 'Bearer realm="NextBlock Cortex AI MCP"',
+    },
+    status: 401,
+  });
+}
+
+export async function POST(request: Request): Promise<Response> {
+  if (!isOriginAllowed(request)) {
+    return new Response(JSON.stringify({ error: 'Origin not allowed.' }), {
+      headers: JSON_HEADERS,
+      status: 403,
+    });
+  }
+
+  const isCortexAiActive = await verifyPackageOnline(CORTEX_AI_PACKAGE_ID);
+
+  if (!isCortexAiActive) {
+    return new Response(
+      JSON.stringify({ error: 'NextBlock Cortex AI is not active for this workspace.' }),
+      { headers: JSON_HEADERS, status: 403 }
+    );
+  }
+
+  const auth = await authenticateMcpRequest(request);
+
+  if (!auth) {
+    return unauthorized(
+      'A valid NextBlock MCP access token is required. Generate one in CMS Settings → Cortex AI, and confirm the MCP server is enabled there.'
+    );
+  }
+
+  let message: JsonRpcMessage;
+
+  try {
+    message = (await request.json()) as JsonRpcMessage;
+  } catch {
+    return new Response(
+      JSON.stringify({
+        error: { code: -32700, message: 'Parse error: request body is not valid JSON.' },
+        id: null,
+        jsonrpc: '2.0',
+      }),
+      { headers: JSON_HEADERS, status: 400 }
+    );
+  }
+
+  const response = await handleCortexMcpMessage(message, {
+    context: buildToolContext(auth),
+    scopes: auth.scopes,
+    serverVersion: SERVER_VERSION,
+  });
+
+  // Notifications and responses: 202 Accepted with no body. Returning a JSON-RPC
+  // envelope for a message that carried no `id` desyncs strict clients.
+  if (response.body === null) {
+    return new Response(null, { status: response.status });
+  }
+
+  return new Response(JSON.stringify(response.body), {
+    headers: JSON_HEADERS,
+    status: response.status,
+  });
+}
+
+/**
+ * The optional server→client SSE stream.
+ *
+ * This server never initiates requests or pushes unsolicited notifications — every
+ * response is returned inline on the POST — so there is nothing to stream. The spec
+ * explicitly permits answering the GET with 405 in that case.
+ */
+export function GET(): Response {
+  return new Response(
+    JSON.stringify({
+      error:
+        'This MCP endpoint does not offer a server-initiated SSE stream. Send JSON-RPC messages via POST.',
+    }),
+    { headers: { ...JSON_HEADERS, Allow: 'POST, DELETE, OPTIONS' }, status: 405 }
+  );
+}
+
+/** Session termination. The server is stateless, so there is no session to tear down. */
+export function DELETE(): Response {
+  return new Response(null, { status: 204 });
+}
+
+export function OPTIONS(): Response {
+  return new Response(null, {
+    headers: {
+      'Access-Control-Allow-Headers':
+        'Authorization, Content-Type, MCP-Protocol-Version, Mcp-Session-Id, Mcp-Method, Mcp-Name',
+      'Access-Control-Allow-Methods': 'POST, DELETE, OPTIONS',
+      Allow: 'POST, DELETE, OPTIONS',
+    },
+    status: 204,
+  });
+}

package/templates/nextblock-template/app/api/view/route.ts

@@ -0,0 +1,114 @@
+import { draftMode } from "next/headers";
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUserCanEdit } from "../../../lib/visual-editing/draft-content";
+import {
+  normalizeDraftRedirectPath,
+  resolveDraftPathTarget,
+  resolveRequestOrigin,
+} from "../../../lib/visual-editing/draft-route";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/**
+ * Entry point behind the CMS "Preview" and "View Live" buttons.
+ *
+ * The public site carries no locale in its URLs: `/[slug]`, `/article/[slug]`,
+ * `/product/[slug]` and `/` all resolve their language per-request from the
+ * `NEXT_USER_LOCALE` cookie (see proxy.ts). A link built from the slug alone
+ * therefore renders in whatever language the *editor's own* cookie says — which,
+ * for an admin working in the CMS, is almost always the default one. Opening the
+ * French version of a page landed you on the English one, three different ways:
+ *
+ *   1. `getPageDataBySlug(slug, cookieLocale)` prefers the row matching the
+ *      cookie, so when two translations share a slug the cookie's language wins.
+ *   2. `PageClientContent` / `PostClientContent` navigate to
+ *      `translatedSlugs[currentLocale]` whenever the rendered row's language
+ *      differs from the cookie — bouncing distinct French slugs back to English.
+ *   3. `/` (the homepage) resolves its language from the cookie with no slug to
+ *      go on at all, so the French homepage was unreachable by URL.
+ *
+ * Pinning the locale here fixes all three at once, because after the redirect the
+ * cookie *agrees* with the content: the server picks the right row, the client
+ * effect is a no-op, and the surrounding chrome (nav, footer, UI strings) renders
+ * in the same language as the body — so the preview isn't lying about the page.
+ *
+ * The alternative, a `?lang=` param read by each route, would leave a second
+ * cacheable variant of every public URL behind and can leak into shares and
+ * search indexes as duplicate content. The redirect lands on the clean canonical
+ * URL instead, and the param never reaches the public route.
+ */
+
+const LANGUAGE_COOKIE_KEY = "NEXT_USER_LOCALE";
+
+function redirectNoStore(url: URL) {
+  const response = NextResponse.redirect(url);
+  response.headers.set("Cache-Control", "no-store");
+  return response;
+}
+
+function redirectToSignIn(request: NextRequest, search: string) {
+  const origin = resolveRequestOrigin(request);
+  const signInUrl = new URL("/sign-in", origin);
+  signInUrl.searchParams.set("redirect", `${request.nextUrl.pathname}${search}`);
+  return redirectNoStore(signInUrl);
+}
+
+export async function GET(request: NextRequest) {
+  const params = request.nextUrl.searchParams;
+  const normalizedPath = normalizeDraftRedirectPath(params.get("path") ?? "/");
+
+  if (!normalizedPath) {
+    return NextResponse.json({ error: "Invalid path." }, { status: 400 });
+  }
+
+  const target = resolveDraftPathTarget(normalizedPath);
+  if (!target) {
+    return NextResponse.json({ error: "Unsupported target path." }, { status: 400 });
+  }
+
+  const wantsDraft = params.get("draft") === "1";
+
+  const auth = await getCurrentUserCanEdit();
+  if (!auth.user) {
+    return redirectToSignIn(request, request.nextUrl.search);
+  }
+  if (!auth.canEdit) {
+    return NextResponse.json(
+      { error: "You do not have permission to preview content." },
+      { status: 403 },
+    );
+  }
+
+  // Only ever write a language the CMS actually has configured — the value lands
+  // in a cookie every public request reads, so it must not be attacker-supplied.
+  let locale: string | null = null;
+  const requestedLang = params.get("lang")?.trim();
+  if (requestedLang) {
+    const { data: language } = await (auth.supabase as any)
+      .from("languages")
+      .select("code")
+      .eq("code", requestedLang)
+      .maybeSingle();
+    locale = (language as { code?: string } | null)?.code ?? null;
+  }
+
+  if (wantsDraft) {
+    const draft = await draftMode();
+    draft.enable();
+  }
+
+  const response = redirectNoStore(new URL(target.path, resolveRequestOrigin(request)));
+
+  if (locale) {
+    // Session-scoped on purpose: previewing French shouldn't pin the editor's own
+    // browsing language for a year. The proxy leaves a matching cookie alone, so
+    // this survives the preview and expires with the browser session.
+    response.cookies.set(LANGUAGE_COOKIE_KEY, locale, {
+      path: "/",
+      sameSite: "lax",
+    });
+  }
+
+  return response;
+}

package/templates/nextblock-template/app/article/[slug]/page.utils.ts

@@ -84,14 +84,13 @@ function applyDraftToPost(post: any, draft: ContentDraftRow) {
     slug: draftString(draft, "slug", post.slug),
     language_id: languageId,
     languages: languageId === post.language_id ? post.languages : null,
-    status: draftString(draft, "status", post.status) as PostType["status"],
+    // Visibility is never taken from a draft — it lives on the row.
     meta_title: draftNullableString(draft, "meta_title", post.meta_title),
     meta_description: draftNullableString(draft, "meta_description", post.meta_description),
     custom_canonical: draftNullableString(draft, "custom_canonical", post.custom_canonical),
     label: draftNullableString(draft, "label", post.label),
     excerpt: draftNullableString(draft, "excerpt", post.excerpt),
     subtitle: draftNullableString(draft, "subtitle", post.subtitle),
-    published_at: draftNullableString(draft, "published_at", post.published_at),
     feature_image_id: draftNullableString(draft, "feature_image_id", post.feature_image_id),
     translation_group_id: draftString(
       draft,

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

@@ -45,8 +45,18 @@ export default function DraftStatusActions({
         );
       }
 
+      const warning = res && "success" in res ? res.warning : undefined;
+
       if (res && "error" in res && res.error) {
         toast.error(`Publish failed: ${res.error}`, { id: toastId });
+      } else if (warning) {
+        // The content IS live — only the revision failed to record. Say so plainly
+        // rather than claiming an unqualified success.
+        toast.error(warning, { id: toastId, duration: 8000 });
+        router.refresh();
+        setTimeout(() => {
+          window.location.reload();
+        }, 800);
       } else {
         toast.success("Changes published live successfully!", { id: toastId });
         router.refresh();

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

@@ -0,0 +1,62 @@
+import { Badge } from "@nextblock-cms/ui";
+import {
+  LIVE_STATUS,
+  resolveVisibilityState,
+  type PublishableType,
+  type VisibilityState,
+} from "@nextblock-cms/utils";
+
+/**
+ * Status badge for the CMS list views.
+ *
+ * Reads the same (status, published_at) pair as the editor's top-bar control, so a
+ * scheduled row is labelled "Scheduled" here instead of claiming to be published
+ * while its URL still 404s.
+ */
+
+const LABEL: Record<VisibilityState, string> = {
+  draft: "Draft",
+  scheduled: "Scheduled",
+  published: "Published",
+  archived: "Archived",
+};
+
+const CLASS_NAME: Record<VisibilityState, string> = {
+  published:
+    "bg-green-100 text-green-700 dark:bg-green-700/30 dark:text-green-300 dark:border-green-700/50",
+  scheduled:
+    "bg-amber-100 text-amber-700 dark:bg-amber-700/30 dark:text-amber-300 dark:border-amber-700/50",
+  draft:
+    "bg-yellow-100 text-yellow-700 dark:bg-yellow-700/30 dark:text-yellow-300 dark:border-yellow-700/50",
+  archived:
+    "bg-slate-100 text-slate-700 dark:bg-slate-700/30 dark:text-slate-300 dark:border-slate-600",
+};
+
+const VARIANT: Record<VisibilityState, "default" | "secondary" | "destructive"> = {
+  published: "default",
+  scheduled: "secondary",
+  draft: "secondary",
+  archived: "destructive",
+};
+
+export default function VisibilityBadge({
+  type,
+  status,
+  publishedAt,
+}: {
+  type: PublishableType;
+  status: string;
+  publishedAt?: string | null;
+}) {
+  const state = resolveVisibilityState({
+    status,
+    publishedAt,
+    liveStatus: LIVE_STATUS[type],
+  });
+
+  return (
+    <Badge variant={VARIANT[state]} className={CLASS_NAME[state]}>
+      {LABEL[state]}
+    </Badge>
+  );
+}