create-nextblock 0.14.5 → 0.14.6

package/templates/nextblock-template/app/cms/settings/cortex-ai/mcp-actions.ts

@@ -0,0 +1,205 @@
+'use server';
+
+import { revalidatePath } from 'next/cache';
+
+import {
+  CORTEX_AI_MCP_SETTINGS_KEY,
+  CORTEX_AI_MCP_TOKENS_TABLE,
+  mintCortexAiMcpToken,
+  normalizeCortexAiMcpSettings,
+  type CortexAiMcpScope,
+  type CortexAiMcpSettings,
+} from '@nextblock-cms/cortex';
+
+import { requireAdminSupabaseClient } from './require-admin';
+
+/**
+ * Server actions for the "MCP server access" card.
+ *
+ * Unlike the rest of `actions.ts`, these return values instead of redirecting with a
+ * `?success=` message. A minted token is displayed exactly once and must never travel
+ * in a URL — it would land in browser history, the referrer header, and the server
+ * access log. Returning it to a client component that renders it in-place and forgets
+ * it keeps the secret out of every one of those.
+ */
+
+const CORTEX_AI_SETTINGS_PATH = '/cms/settings/cortex-ai';
+
+const MAX_TOKEN_NAME_LENGTH = 80;
+const MAX_TOKENS = 20;
+
+export type McpAccessTokenSummary = {
+  createdAt: string;
+  expiresAt: string | null;
+  id: string;
+  lastUsedAt: string | null;
+  name: string;
+  scopes: CortexAiMcpScope[];
+  tokenPrefix: string;
+};
+
+export type McpSettingsStatus = {
+  settings: CortexAiMcpSettings;
+  tokens: McpAccessTokenSummary[];
+};
+
+function toScopeList(raw: unknown): CortexAiMcpScope[] {
+  const list = Array.isArray(raw) ? raw : [];
+  const scopes = list.filter(
+    (entry): entry is CortexAiMcpScope => entry === 'read' || entry === 'write'
+  );
+
+  return scopes.length > 0 ? Array.from(new Set(scopes)) : ['read'];
+}
+
+/**
+ * Load MCP settings and the non-secret token list.
+ *
+ * Revoked tokens are filtered out rather than deleted at revoke time so the row keeps
+ * acting as a tombstone: the hash stays in the unique index, which makes an
+ * accidental re-mint of the same value impossible.
+ */
+export async function getMcpSettingsStatus(): Promise<McpSettingsStatus> {
+  const { supabase } = await requireAdminSupabaseClient();
+
+  const [{ data: settingsRow }, { data: tokenRows }] = await Promise.all([
+    supabase.from('site_settings').select('value').eq('key', CORTEX_AI_MCP_SETTINGS_KEY).maybeSingle(),
+    supabase
+      .from(CORTEX_AI_MCP_TOKENS_TABLE)
+      .select('id, name, scopes, token_prefix, created_at, expires_at, last_used_at, revoked_at')
+      .is('revoked_at', null)
+      .order('created_at', { ascending: false })
+      .limit(MAX_TOKENS),
+  ]);
+
+  return {
+    settings: normalizeCortexAiMcpSettings(settingsRow?.value),
+    tokens: (tokenRows ?? []).map((row: Record<string, any>) => ({
+      createdAt: row.created_at,
+      expiresAt: row.expires_at,
+      id: row.id,
+      lastUsedAt: row.last_used_at,
+      name: row.name,
+      scopes: toScopeList(row.scopes),
+      tokenPrefix: row.token_prefix,
+    })),
+  };
+}
+
+export async function saveMcpSettingsAction(input: {
+  allowLocalhostWithoutToken: boolean;
+  enabled: boolean;
+}): Promise<{ error?: string; success: boolean }> {
+  try {
+    const { supabase } = await requireAdminSupabaseClient();
+    const value = normalizeCortexAiMcpSettings(input);
+
+    const { error } = await supabase
+      .from('site_settings')
+      .upsert({ key: CORTEX_AI_MCP_SETTINGS_KEY, value });
+
+    if (error) {
+      throw new Error(error.message);
+    }
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : 'Failed to save MCP server settings.',
+      success: false,
+    };
+  }
+
+  revalidatePath(CORTEX_AI_SETTINGS_PATH);
+  return { success: true };
+}
+
+export async function createMcpAccessTokenAction(input: {
+  expiresInDays?: number | null;
+  name: string;
+  scopes: CortexAiMcpScope[];
+}): Promise<{ error?: string; success: boolean; token?: string; tokenPrefix?: string }> {
+  try {
+    const { supabase, userId } = await requireAdminSupabaseClient();
+
+    const name = String(input.name || '').trim().slice(0, MAX_TOKEN_NAME_LENGTH);
+
+    if (!name) {
+      throw new Error('Give the token a name so you can tell your clients apart later.');
+    }
+
+    const scopes = toScopeList(input.scopes);
+
+    const { count } = await supabase
+      .from(CORTEX_AI_MCP_TOKENS_TABLE)
+      .select('id', { count: 'exact', head: true })
+      .is('revoked_at', null);
+
+    if ((count ?? 0) >= MAX_TOKENS) {
+      throw new Error(
+        `You already have ${MAX_TOKENS} active MCP tokens. Revoke one before creating another.`
+      );
+    }
+
+    const expiresInDays =
+      typeof input.expiresInDays === 'number' && Number.isFinite(input.expiresInDays)
+        ? Math.min(3650, Math.max(1, Math.round(input.expiresInDays)))
+        : null;
+
+    const expiresAt = expiresInDays
+      ? new Date(Date.now() + expiresInDays * 24 * 60 * 60 * 1000).toISOString()
+      : null;
+
+    const minted = mintCortexAiMcpToken();
+
+    const { error } = await supabase.from(CORTEX_AI_MCP_TOKENS_TABLE).insert({
+      created_by: userId,
+      expires_at: expiresAt,
+      name,
+      scopes,
+      token_hash: minted.tokenHash,
+      token_prefix: minted.tokenPrefix,
+    });
+
+    if (error) {
+      throw new Error(error.message);
+    }
+
+    revalidatePath(CORTEX_AI_SETTINGS_PATH);
+
+    return { success: true, token: minted.token, tokenPrefix: minted.tokenPrefix };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : 'Failed to create the MCP access token.',
+      success: false,
+    };
+  }
+}
+
+export async function revokeMcpAccessTokenAction(input: {
+  id: string;
+}): Promise<{ error?: string; success: boolean }> {
+  try {
+    const { supabase } = await requireAdminSupabaseClient();
+    const id = String(input.id || '').trim();
+
+    if (!id) {
+      throw new Error('Missing token id.');
+    }
+
+    const { error } = await supabase
+      .from(CORTEX_AI_MCP_TOKENS_TABLE)
+      .update({ revoked_at: new Date().toISOString() })
+      .eq('id', id);
+
+    if (error) {
+      throw new Error(error.message);
+    }
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : 'Failed to revoke the MCP access token.',
+      success: false,
+    };
+  }
+
+  revalidatePath(CORTEX_AI_SETTINGS_PATH);
+  return { success: true };
+}

package/templates/nextblock-template/app/cms/settings/cortex-ai/page.tsx

@@ -1,5 +1,9 @@
+import { headers } from 'next/headers';
+
 import { listCortexAiCompatibleOpenRouterModels } from '@nextblock-cms/cortex';
 import { getCortexAiSettingsStatus } from './actions';
+import { getMcpSettingsStatus } from './mcp-actions';
+import { McpServerSettingsCard } from './McpServerSettingsCard';
 import { SandboxCortexAiSettingsClient } from './SandboxCortexAiSettingsClient';
 import { StoredCortexAiSettingsClient } from './StoredCortexAiSettingsClient';
 import { redirect } from 'next/navigation';
@@ -22,6 +26,51 @@ function formatDate(value: string | null) {
   }).format(new Date(value));
 }
 
+/**
+ * The origin an external MCP client should dial.
+ *
+ * Prefers NEXT_PUBLIC_URL (the deployed canonical origin) and falls back to the
+ * request's own host, so the snippet is correct on a preview deployment or a custom
+ * domain that was never written into the env.
+ */
+async function resolveSiteOrigin(): Promise<string> {
+  const configured = process.env.NEXT_PUBLIC_URL?.trim();
+
+  if (configured) {
+    return configured.replace(/\/+$/, '');
+  }
+
+  const headerList = await headers();
+  const host = headerList.get('host');
+
+  if (!host) {
+    return 'https://your-site.com';
+  }
+
+  const protocol = headerList.get('x-forwarded-proto') || (host.startsWith('localhost') ? 'http' : 'https');
+
+  return `${protocol}://${host}`;
+}
+
+/**
+ * The loopback origin to show in the "Localhost" client snippets.
+ *
+ * Ports differ per setup — `nx serve nextblock` uses Nx's default 4200, not Next's
+ * plain 3000 — and a snippet pointing at the wrong port fails with a bare connection
+ * error that gives the reader nothing to go on. When this page is itself being viewed
+ * over loopback, that request's own host is the authoritative answer.
+ */
+async function resolveLocalOrigin(): Promise<string> {
+  const headerList = await headers();
+  const host = headerList.get('host')?.trim();
+
+  if (host && /^(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i.test(host)) {
+    return `http://${host}`;
+  }
+
+  return 'http://localhost:4200';
+}
+
 export default async function CortexAiSettingsPage({
   searchParams,
 }: CortexAiSettingsPageProps) {
@@ -70,6 +119,12 @@ export default async function CortexAiSettingsPage({
     );
   }
 
+  const [mcpStatus, siteOrigin, localOrigin] = await Promise.all([
+    getMcpSettingsStatus(),
+    resolveSiteOrigin(),
+    resolveLocalOrigin(),
+  ]);
+
   return (
     <StoredCortexAiSettingsClient
       compatibleModels={compatibleModels as any}
@@ -95,6 +150,14 @@ export default async function CortexAiSettingsPage({
       agentSettings={status.agentSettings}
       successMessage={params.success}
       errorMessage={params.error}
-    />
+    >
+      <McpServerSettingsCard
+        allowLocalhostWithoutToken={mcpStatus.settings.allowLocalhostWithoutToken}
+        enabled={mcpStatus.settings.enabled}
+        localMcpUrl={`${localOrigin}/api/mcp`}
+        mcpUrl={`${siteOrigin}/api/mcp`}
+        tokens={mcpStatus.tokens}
+      />
+    </StoredCortexAiSettingsClient>
   );
 }

package/templates/nextblock-template/app/cms/settings/cortex-ai/require-admin.ts

@@ -0,0 +1,34 @@
+import { createClient } from '@nextblock-cms/db/server';
+
+/**
+ * Admin gate shared by the Cortex AI settings server actions.
+ *
+ * Lives outside `actions.ts` because that file is `'use server'`, where every export
+ * must itself be a valid server action — a helper returning a Supabase client cannot
+ * be exported from there. Keeping one copy matters more than the file count: this is
+ * the check standing between a WRITER and the OpenRouter key, the stock-photo keys,
+ * and the MCP access tokens.
+ */
+export async function requireAdminSupabaseClient() {
+  const supabase = createClient();
+  const {
+    data: { user },
+    error: userError,
+  } = await supabase.auth.getUser();
+
+  if (userError || !user) {
+    throw new Error('You must be logged in to manage Cortex AI settings.');
+  }
+
+  const { data: profile, error: profileError } = await supabase
+    .from('profiles')
+    .select('role')
+    .eq('id', user.id)
+    .single();
+
+  if (profileError || !profile || profile.role !== 'ADMIN') {
+    throw new Error('You do not have permission to manage Cortex AI settings.');
+  }
+
+  return { supabase, userId: user.id };
+}

package/templates/nextblock-template/docs/04-DATABASE-AND-AUTH.md

@@ -198,7 +198,13 @@ production or shared database change.
   `libs/db/src/supabase/migrations` for each new schema/data change.
 - Keep migrations non-destructive by default. Avoid dropping or rewriting data
   that may include orders, users, payments, or customer records.
-- Run `npm run db:migrate:check` before `npm run db:migrate`.
+- Run `npm run db:migrate:check` before `npm run db:migrate`. **Read its pending
+  list** — do not just look for a success line. If you added a migration and the
+  check reports `Pending: 0`, that file will never run (see below).
+- **Supabase matches migration history by version only, never by content.** A file
+  whose 14-digit version is already recorded remotely is skipped in silence — no
+  error, no output. That is why the check prints the pending list and warns when a
+  version is recorded remotely with no local file behind it.
 - If an existing database lists old baseline files such as
   `00000000000000_baseline_schema.sql` as pending, do not replay them. Use
   `npm run db:migrate:repair-history:check`, then
@@ -207,6 +213,30 @@ production or shared database change.
   rerun `npm run db:migrate:check`.
 - Use `npm run db:migrate:fresh` only for a brand-new empty database.
 
+#### Why `db:migrate:check` is read-only by construction
+
+On 2026-08-10 the check applied migration `00000000000017` to the production
+project while printing `DRY RUN: migrations will *not* be pushed` and `Dry run
+complete. No database changes were applied.` The `--check` path then ran
+`supabase link --yes` followed by `supabase db push --dry-run` (Supabase CLI
+v2.107); which of the two executed the SQL was never established, and the decisive
+probe would have written a row to the production migration history.
+
+`tools/scripts/push-db-migrations.js` no longer runs either on the check path. It
+now runs only `supabase migration list` — a pure read — and derives the pending set
+by diffing local files against remote history. Consequences worth keeping:
+
+- The check links nothing. An unlinked repo is told to run `supabase link` itself
+  rather than having project state written underneath a command called "check".
+- The check needs no `SUPABASE_ACCESS_TOKEN`, because only linking did.
+- The apply path derives its baseline-replay guard from the same read instead of
+  regex-scraping `db push --dry-run` output, and returns early when nothing is
+  pending, so `db push` is never invoked without work to do.
+- `parseMigrationList` is unit-tested in `tools/scripts/push-db-migrations.test.ts`.
+
+If a future CLI upgrade tempts you back toward `db push --dry-run` for previewing:
+don't. A command named `check` must not be able to write.
+
 ### Category map
 
 | Migration file | Domain | What it covers |

package/templates/nextblock-template/docs/08-NEXTBLOCK-CORTEX-AI-ARCHITECTURE.md

@@ -1060,6 +1060,157 @@ Unsplash has strict usage rules; Pexels' license is permissive (attribution opti
 - `importExternalImageToMedia` (`apps/nextblock/app/cms/media/import-external-image.ts`, ADMIN/WRITER) downloads an external image (SSRF-guarded, 15MB/15s caps), measures it with `sharp`, generates a blur placeholder, uploads to R2/Supabase Storage via the shared storage provider, and records it with `recordMediaUpload`. Returns `{ media_id, object_key, width, height, url, blur_data_url }`.
 - Editor UX: `ImageBlockEditor` and `BackgroundSelector` accept a pasted image URL and show a **Save to media library** action that swaps the external URL for a permanent optimized media reference (or the author can replace it with their own uploaded asset).
 
+## MCP Server (external client access)
+
+Cortex AI is dual-access. Alongside the in-app BYOK path (dashboard chat + inline
+editor), the same tool registry is exposed over the **Model Context Protocol** at
+`/api/mcp`, so Claude Code, Claude Desktop, Cursor, and VS Code can operate the CMS
+from inside the editor.
+
+### Files
+
+| File | Purpose |
+| --- | --- |
+| `libs/cortex/src/lib/mcp-server.ts` | Transport-agnostic JSON-RPC 2.0 engine. No `next` imports, so it is unit-testable. |
+| `libs/cortex/src/lib/mcp-tool-registry.ts` | Zod→JSON Schema conversion, read/write scope table, MCP-contract aliases, tool dispatch, resources, prompts. |
+| `libs/cortex/src/lib/mcp-tokens.ts` | Token mint/hash/verify, MCP settings resolver, localhost-trust rules. |
+| `libs/cortex/src/lib/mcp-server.test.ts` | 33 tests across tokens, registry, and protocol. |
+| `apps/nextblock/app/api/mcp/route.ts` | Streamable HTTP shim + hybrid auth + tool-context construction. |
+| `apps/nextblock/app/cms/settings/cortex-ai/mcp-actions.ts` | Admin server actions: settings, mint, revoke. |
+| `apps/nextblock/app/cms/settings/cortex-ai/McpServerSettingsCard.tsx` | Settings UI + copy-paste client config. |
+| `apps/nextblock/app/cms/settings/cortex-ai/require-admin.ts` | Shared admin gate (also used by `actions.ts`). |
+| `libs/db/src/supabase/migrations/00000000000017_cortex_ai_mcp_server.sql` | `mcp_access_tokens` table + `cortex_ai_mcp_settings` RLS. |
+
+### Protocol decisions
+
+**Hand-rolled, not `@modelcontextprotocol/sdk`.** The needed surface (initialize,
+tools/list, tools/call, resources/*, prompts/*, ping) is small and declarative. The v1
+SDK pulls in `express`, `cors`, `hono`, and `@hono/node-server` — heavy transitive
+weight for a publishable lib whose only peer dependency is `next` — and its default
+`StreamableHTTPServerTransport` is built on Node `IncomingMessage`/`ServerResponse`
+rather than the Web `Request`/`Response` an App Router handler receives.
+
+**Dual-era.** The spec forked: `2026-07-28` is stateless (no `initialize`, no session
+id, protocol metadata in a per-request `_meta` envelope), while everything through
+`2025-11-25` is handshake-based. As of 2026-08 every shipping client is legacy-era, so
+that path must work; the modern path is detected and served too. Because the server is
+stateless either way, supporting both costs nothing.
+
+Deliberate behaviours, each of which breaks a real client if changed:
+
+- **Notifications get `202 Accepted` with an empty body.** Returning a JSON-RPC
+  envelope for a message with no `id` desyncs strict clients.
+- **GET returns `405`.** The server never initiates requests or pushes unsolicited
+  notifications, so there is no stream to open. The spec explicitly allows 405 here.
+- **401 carries a bare `WWW-Authenticate: Bearer`.** Adding a `resource_metadata`
+  parameter (or serving `/.well-known/oauth-protected-resource`) advertises RFC 9728
+  OAuth discovery, and Claude Code responds by starting an OAuth flow that dead-ends
+  against a static-token server.
+- **Tool failures are `isError: true` on a *successful* result**, not JSON-RPC errors.
+  Only unknown-tool and scope denial use the error channel, because those are the
+  faults a model cannot fix by retrying with different arguments.
+- **`inputSchema` is always a JSON Schema object** with `$schema` stripped (MCP defines
+  the dialect; some clients reject the extra key). Converted with `io: 'input'` so
+  `.default()` fields stay optional.
+- **Array bodies are rejected.** JSON-RPC batching was removed in `2025-06-18`.
+- **`Origin` is validated when present** (DNS-rebinding defence, a spec MUST) and
+  answered with 403. Native clients send no Origin, so absence is allowed.
+
+### Authentication
+
+Three accepted paths, in priority order, all gated behind
+`verifyPackageOnline('cortex-ai')` and the `enabled` setting:
+
+1. **Bearer token** from `public.mcp_access_tokens` — what every external client uses.
+2. **Authenticated ADMIN cookie session** — lets the dashboard reach the endpoint
+   without minting a token.
+3. **Loopback in development** — only when `allowLocalhostWithoutToken` is on *and*
+   `NODE_ENV !== 'production'`. Behind a proxy the `Host` header is attacker-
+   controllable, so localhost trust is a development affordance only.
+
+Tokens are stored as **SHA-256 hashes**; the plaintext (`nbmcp_` + 256 bits base64url)
+is shown once at mint time and is unrecoverable. This differs from the OpenRouter BYOK
+key on purpose: that key must be handed back to OpenRouter, so it needs a reversible
+envelope, whereas an MCP token only ever needs to be *compared*. `token_prefix` is a
+non-secret display fragment. Revocation is a tombstone (`revoked_at`), which keeps the
+hash in the unique index so the same value can never be re-minted.
+
+The minted token is returned through a **server action return value**, never a redirect
+query string — a `?success=<token>` would land in browser history, the referrer header,
+and the server access log.
+
+### Scopes
+
+`CORTEX_MCP_TOOL_KINDS` classifies all 29 registry tools as `read` or `write`. A
+read-only token does not merely get refused on a write — the mutating tools are absent
+from its `tools/list` entirely, aliases included.
+
+The table is **exhaustive by construction**: `assertCortexMcpToolCoverage` compares its
+keys against the live factory output, and a unit test fails if they diverge. An
+unclassified tool is *withheld*, never defaulted to `read`, so adding a tool to the
+agent without classifying it is a loud failure rather than a silent hole.
+
+### Confirmation is skipped over MCP
+
+The in-app two-phase confirm matches a phrase in the user's *next chat message*, which
+has no analogue in MCP — there is no channel to carry a human phrase back between a
+tool call and its result. Every MCP host already gates tool calls behind its own
+approval UI, so leaving it on would just make every mutating tool return a preview
+forever. The real control is the token scope. `ToolExecutionContext.skipConfirmation`
+is therefore `true` for all MCP calls.
+
+### MCP-contract tool names
+
+Five names are exposed as aliases forwarding to existing executors, so external clients
+get the documented contract without forking tested code. The canonical names remain
+listed too, and each alias description begins with "Alias of `<canonical>`" so a model
+does not call both.
+
+| MCP name | Forwards to |
+| --- | --- |
+| `get_database_schema` | `describe_database_schema` |
+| `generate_jsonb_layout` | `rewrite_page_draft` (stages a Live Draft; nothing goes live unpublished) |
+| `query_site_analytics` | `fetch_ecommerce_stats` |
+| `update_site_navigation` | `update_navigation_bar` |
+| `search_stock_media` | `search_stock_photos` |
+
+### Resources and prompts
+
+Resources: `cortex://schema/database`, `cortex://schema/blocks`,
+`cortex://schema/custom-blocks`. Prompts: `build-page`, `clone-from-url`,
+`translate-content`.
+
+### Settings and client configuration
+
+`/cms/settings/cortex-ai` gains an "MCP server access" card: enable/disable, localhost
+trust, token mint/revoke, and copy-paste config for all four clients. **The server is
+disabled by default** — it is a remote write surface onto live content, so it must be
+an explicit opt-in.
+
+Client config differs in ways that silently no-op if copied wrong, which is why the UI
+generates each one rather than documenting a single snippet:
+
+- **Claude Code** — `mcpServers`, and `"type": "http"` is *required* (a `url` with no
+  `type` is a hard error that skips the server).
+- **Cursor** — `mcpServers`, infers transport from `url`, no `type` needed.
+- **VS Code** — top-level `servers`, **not** `mcpServers`, and prompts for the token
+  via `inputs` rather than storing it.
+- **Claude Desktop** — `claude_desktop_config.json` is stdio-only, so a remote server
+  needs either the Connectors UI (which dials out from Anthropic's cloud, so localhost
+  and firewalled sites will not connect) or the `mcp-remote` stdio bridge.
+
+### Related hardening
+
+`read_database_records` previously filtered only `cortex_ai_openrouter_api_key` from
+`site_settings`. The `isSensitiveKey` heuristic inspects *column names*, and a
+site_settings row is `{ key, value }` — neither name trips it, so the stock-photo and
+payment/email secret rows passed through. That was low-risk while the tool was
+dashboard-only; exposing it to remote MCP clients widened it. `ai-global-agent-db-tools.ts`
+now carries `PROTECTED_SITE_SETTING_KEYS`, redacted on read and refused on write.
+
+`mcp_access_tokens` is deliberately **absent** from `tableConfigs`, so the generic DB
+tools cannot read token hashes or insert rows.
+
 ## Advanced Agent Settings
 
 The global agent's model limits are admin-tunable from `/cms/settings/cortex-ai` (collapsible "Advanced settings"), stored as a non-secret JSON `site_settings` row `cortex_ai_agent_settings` and read by the route via `resolveCortexAiAgentSettings(supabase)` (defaults + clamping in `normalizeCortexAiAgentSettings`, `libs/cortex/src/lib/ai-config.ts`):

package/templates/nextblock-template/lib/setup/migrations-bundle.ts

@@ -98,5 +98,10 @@ export const MIGRATIONS_BUNDLE: BundledMigration[] = [
     "version": "00000000000016",
     "name": "00000000000016_product_revisions_and_revision_baseline.sql",
     "sql": "-- 00000000000016_product_revisions_and_revision_baseline.sql\n--\n-- Revision History, part 1 of 2 (schema). The application-side rewrite lives in\n-- apps/nextblock/app/cms/revisions/**.\n--\n-- Three things happen here:\n--\n--   1. products.version    — the monotonic counter the hybrid revision engine drives,\n--                            mirroring pages.version / posts.version.\n--\n--   2. product_revisions   — a structural mirror of page_revisions / post_revisions.\n--                            product_id is uuid (products.id is uuid, not bigint), and\n--                            writes are gated on is_admin() to match products_*_policy\n--                            rather than the ADMIN|WRITER pattern the page/post revision\n--                            tables use. A WRITER who could insert a revision but not\n--                            apply a restore would get a silent no-op restore, because\n--                            PostgREST returns no error for an UPDATE matching zero rows.\n--\n--   3. Revision baseline   — every page, post and product gets a real `snapshot` row to\n--                            restore to. Until now the CMS synthesised a fake \"Initial\n--                            Version\" entry in the UI whose Restore button resolved to\n--                            \"current metadata + zero blocks\" and wiped the content.\n--                            There is now an actual stored baseline instead.\n--\n--                            Case A (version = 1, no revisions at all): the live row IS\n--                            version 1. This covers seeded content — 00000000000003\n--                            inserts every page and post at version 1 and writes no\n--                            revision rows — and everything authored since the CMS save\n--                            path stopped recording revisions. Snapshotting it at\n--                            version 1 is what makes \"restore the original seeded page\"\n--                            real for the first time.\n--\n--                            Case B (version > 1 but no snapshot at or below it): the\n--                            true v1 is unrecoverable and is NOT fabricated. A snapshot\n--                            of the current state is stored at the current version so the\n--                            diff chain has a valid base and future restores resolve.\n--\n-- Forward-only, idempotent, and it modifies no existing row: every backfill is an\n-- INSERT ... WHERE NOT EXISTS ... ON CONFLICT DO NOTHING.\n\n-- ---------------------------------------------------------------------------\n-- 1. products.version\n-- ---------------------------------------------------------------------------\n\nALTER TABLE public.products\n    ADD COLUMN IF NOT EXISTS version integer DEFAULT 1 NOT NULL;\n\nCOMMENT ON COLUMN public.products.version IS 'Monotonic version number for hybrid revisions.';\n\n-- ---------------------------------------------------------------------------\n-- 2. product_revisions\n-- ---------------------------------------------------------------------------\n\nCREATE TABLE IF NOT EXISTS public.product_revisions (\n    id bigint NOT NULL,\n    product_id uuid NOT NULL,\n    author_id uuid,\n    version integer NOT NULL,\n    revision_type public.revision_type NOT NULL,\n    content jsonb NOT NULL,\n    created_at timestamp with time zone DEFAULT now() NOT NULL\n);\n\nCOMMENT ON TABLE public.product_revisions IS 'Hybrid (snapshot/diff) revisions for products.';\nCOMMENT ON COLUMN public.product_revisions.content IS 'If snapshot: full content; if diff: JSON Patch array.';\n\nDO $rb$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_attribute\n     WHERE attrelid = 'public.product_revisions'::regclass\n       AND attname  = 'id'\n       AND attidentity <> ''\n  ) THEN\n    ALTER TABLE public.product_revisions\n      ALTER COLUMN id ADD GENERATED BY DEFAULT AS IDENTITY (\n        SEQUENCE NAME public.product_revisions_id_seq\n        START WITH 1\n        INCREMENT BY 1\n        NO MINVALUE\n        NO MAXVALUE\n        CACHE 1\n      );\n  END IF;\nEND $rb$;\n\nDO $rb$\nBEGIN\n  IF NOT EXISTS (SELECT 1 FROM pg_constraint\n                  WHERE conname = 'product_revisions_pkey'\n                    AND conrelid = 'public.product_revisions'::regclass) THEN\n    ALTER TABLE ONLY public.product_revisions\n      ADD CONSTRAINT product_revisions_pkey PRIMARY KEY (id);\n  END IF;\nEND $rb$;\n\nDO $rb$\nBEGIN\n  IF NOT EXISTS (SELECT 1 FROM pg_constraint\n                  WHERE conname = 'product_revisions_product_version_key'\n                    AND conrelid = 'public.product_revisions'::regclass) THEN\n    ALTER TABLE ONLY public.product_revisions\n      ADD CONSTRAINT product_revisions_product_version_key UNIQUE (product_id, version);\n  END IF;\nEND $rb$;\n\nDO $rb$\nBEGIN\n  IF NOT EXISTS (SELECT 1 FROM pg_constraint\n                  WHERE conname = 'product_revisions_author_id_fkey'\n                    AND conrelid = 'public.product_revisions'::regclass) THEN\n    ALTER TABLE ONLY public.product_revisions\n      ADD CONSTRAINT product_revisions_author_id_fkey\n      FOREIGN KEY (author_id) REFERENCES public.profiles(id) ON DELETE SET NULL;\n  END IF;\nEND $rb$;\n\nDO $rb$\nBEGIN\n  IF NOT EXISTS (SELECT 1 FROM pg_constraint\n                  WHERE conname = 'product_revisions_product_id_fkey'\n                    AND conrelid = 'public.product_revisions'::regclass) THEN\n    ALTER TABLE ONLY public.product_revisions\n      ADD CONSTRAINT product_revisions_product_id_fkey\n      FOREIGN KEY (product_id) REFERENCES public.products(id) ON DELETE CASCADE;\n  END IF;\nEND $rb$;\n\nCREATE INDEX IF NOT EXISTS idx_product_revisions_author_id\n    ON public.product_revisions USING btree (author_id);\n\nCREATE INDEX IF NOT EXISTS idx_product_revisions_product_id_version\n    ON public.product_revisions USING btree (product_id, version);\n\nALTER TABLE public.product_revisions ENABLE ROW LEVEL SECURITY;\n\nDROP POLICY IF EXISTS product_revisions_read_policy ON public.product_revisions;\nCREATE POLICY product_revisions_read_policy ON public.product_revisions\n  FOR SELECT TO authenticated USING (true);\n\nDROP POLICY IF EXISTS product_revisions_insert_policy ON public.product_revisions;\nCREATE POLICY product_revisions_insert_policy ON public.product_revisions\n  FOR INSERT TO authenticated\n  WITH CHECK (((SELECT public.is_admin() AS is_admin) IS TRUE));\n\nDROP POLICY IF EXISTS product_revisions_update_policy ON public.product_revisions;\nCREATE POLICY product_revisions_update_policy ON public.product_revisions\n  FOR UPDATE TO authenticated\n  USING (((SELECT public.is_admin() AS is_admin) IS TRUE))\n  WITH CHECK (((SELECT public.is_admin() AS is_admin) IS TRUE));\n\nDROP POLICY IF EXISTS product_revisions_delete_policy ON public.product_revisions;\nCREATE POLICY product_revisions_delete_policy ON public.product_revisions\n  FOR DELETE TO authenticated\n  USING (((SELECT public.is_admin() AS is_admin) IS TRUE));\n\nGRANT ALL ON TABLE    public.product_revisions        TO anon;\nGRANT ALL ON TABLE    public.product_revisions        TO authenticated;\nGRANT ALL ON TABLE    public.product_revisions        TO service_role;\nGRANT ALL ON SEQUENCE public.product_revisions_id_seq TO anon;\nGRANT ALL ON SEQUENCE public.product_revisions_id_seq TO authenticated;\nGRANT ALL ON SEQUENCE public.product_revisions_id_seq TO service_role;\n\n-- ---------------------------------------------------------------------------\n-- 3. Revision baseline backfill\n--\n-- The JSON shape must match FullPageContent / FullPostContent / FullProductContent\n-- in apps/nextblock/app/cms/revisions/utils.ts exactly, or the first diff taken\n-- against a baseline row will be full of phantom operations.\n--\n-- Timestamps are rendered with an explicit millisecond-precision UTC format so they\n-- match JavaScript's Date#toISOString() (\"2026-07-03T17:52:15.643Z\"). Postgres'\n-- default jsonb rendering of timestamptz (\"2026-07-03T17:52:15.643901+00:00\") would\n-- differ from the value the application writes and produce a spurious diff on the\n-- very next save.\n-- ---------------------------------------------------------------------------\n\n-- 3a. Pages\nINSERT INTO public.page_revisions (page_id, author_id, version, revision_type, content)\nSELECT\n    p.id,\n    NULL::uuid,\n    p.version,\n    'snapshot'::public.revision_type,\n    jsonb_build_object(\n      'meta', jsonb_build_object(\n        'title',            p.title,\n        'slug',             p.slug,\n        'language_id',      p.language_id,\n        'status',           p.status,\n        'meta_title',       p.meta_title,\n        'meta_description', p.meta_description,\n        'custom_canonical', p.custom_canonical,\n        'published_at',     to_char(p.published_at AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"'),\n        'feature_image_id', p.feature_image_id\n      ),\n      'blocks', COALESCE((\n        SELECT jsonb_agg(\n                 jsonb_build_object(\n                   'language_id', b.language_id,\n                   'block_type',  b.block_type,\n                   'content',     b.content,\n                   'order',       b.\"order\"\n                 ) ORDER BY b.\"order\" ASC, b.id ASC\n               )\n          FROM public.blocks b\n         WHERE b.page_id = p.id\n      ), '[]'::jsonb)\n    )\n  FROM public.pages p\n WHERE NOT EXISTS (\n         SELECT 1 FROM public.page_revisions r\n          WHERE r.page_id = p.id\n            AND r.revision_type = 'snapshot'\n            AND r.version <= p.version\n       )\nON CONFLICT (page_id, version) DO NOTHING;\n\n-- 3b. Posts\nINSERT INTO public.post_revisions (post_id, author_id, version, revision_type, content)\nSELECT\n    po.id,\n    NULL::uuid,\n    po.version,\n    'snapshot'::public.revision_type,\n    jsonb_build_object(\n      'meta', jsonb_build_object(\n        'title',            po.title,\n        'slug',             po.slug,\n        'language_id',      po.language_id,\n        'status',           po.status,\n        'meta_title',       po.meta_title,\n        'meta_description', po.meta_description,\n        'custom_canonical', po.custom_canonical,\n        'published_at',     to_char(po.published_at AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"'),\n        'feature_image_id', po.feature_image_id,\n        'label',            po.label,\n        'excerpt',          po.excerpt,\n        'subtitle',         po.subtitle\n      ),\n      'blocks', COALESCE((\n        SELECT jsonb_agg(\n                 jsonb_build_object(\n                   'language_id', b.language_id,\n                   'block_type',  b.block_type,\n                   'content',     b.content,\n                   'order',       b.\"order\"\n                 ) ORDER BY b.\"order\" ASC, b.id ASC\n               )\n          FROM public.blocks b\n         WHERE b.post_id = po.id\n      ), '[]'::jsonb)\n    )\n  FROM public.posts po\n WHERE NOT EXISTS (\n         SELECT 1 FROM public.post_revisions r\n          WHERE r.post_id = po.id\n            AND r.revision_type = 'snapshot'\n            AND r.version <= po.version\n       )\nON CONFLICT (post_id, version) DO NOTHING;\n\n-- 3c. Products.\n--\n-- Content only. price/prices/sale_*/scheduled_*/stock/sku/average_rating/total_reviews\n-- are deliberately excluded from the snapshot: pricing and inventory are mutated from\n-- outside the editor (promotions, Freemius sync, order fulfilment), ratings are derived\n-- aggregates, and inventory_items is keyed by bare SKU text with no FK to products — so\n-- replaying commerce state on restore would reach rows the editor never touched.\n-- Restoring a product restores its content, not its commerce state.\nINSERT INTO public.product_revisions (product_id, author_id, version, revision_type, content)\nSELECT\n    pr.id,\n    NULL::uuid,\n    pr.version,\n    'snapshot'::public.revision_type,\n    jsonb_build_object(\n      'meta', jsonb_build_object(\n        'title',             pr.title,\n        'slug',              pr.slug,\n        'language_id',       pr.language_id,\n        'status',            pr.status,\n        'meta_title',        pr.meta_title,\n        'meta_description',  pr.meta_description,\n        'custom_canonical',  pr.custom_canonical,\n        'published_at',      to_char(pr.published_at AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"'),\n        'short_description', pr.short_description,\n        'description_json',  pr.description_json\n      ),\n      'blocks', COALESCE((\n        SELECT jsonb_agg(\n                 jsonb_build_object(\n                   'language_id', b.language_id,\n                   'block_type',  b.block_type,\n                   'content',     b.content,\n                   'order',       b.\"order\"\n                 ) ORDER BY b.\"order\" ASC, b.id ASC\n               )\n          FROM public.blocks b\n         WHERE b.product_id = pr.id\n      ), '[]'::jsonb)\n    )\n  FROM public.products pr\n WHERE NOT EXISTS (\n         SELECT 1 FROM public.product_revisions r\n          WHERE r.product_id = pr.id\n            AND r.revision_type = 'snapshot'\n            AND r.version <= pr.version\n       )\nON CONFLICT (product_id, version) DO NOTHING;\n"
+  },
+  {
+    "version": "00000000000017",
+    "name": "00000000000017_cortex_ai_mcp_server.sql",
+    "sql": "-- Cortex AI MCP (Model Context Protocol) server access.\n--\n-- Adds the bearer-token store that gates /api/mcp, the endpoint that exposes the\n-- Cortex AI tool registry to external MCP clients (Claude Code, Claude Desktop,\n-- Cursor, VS Code). Two pieces:\n--\n--   1. public.mcp_access_tokens — one row per issued token. We store ONLY the\n--      SHA-256 hash of the token, never the token itself: the plaintext is shown\n--      to the admin exactly once at mint time and is unrecoverable afterwards, so\n--      a database leak cannot be replayed against the MCP endpoint. `token_prefix`\n--      is the non-secret leading fragment kept purely so the UI can tell two tokens\n--      apart in a list.\n--\n--   2. cortex_ai_mcp_settings — a non-secret JSON site_settings row holding the\n--      server on/off switch and the localhost-trust flag. It is added to all four\n--      site_settings policies so only authenticated ADMINs can read or write it;\n--      the MCP route itself reads it through the service-role client, which\n--      bypasses RLS.\n--\n-- Forward-only. Recreates the four site_settings policies idempotently, preserving\n-- every key already in each policy's sensitive array (note that\n-- language_detection_settings stays anon-READABLE and so is absent from the SELECT\n-- policy, exactly as migration 00000000000012 left it).\n\nCREATE TABLE IF NOT EXISTS public.mcp_access_tokens (\n  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),\n  name text NOT NULL,\n  -- Lowercase hex SHA-256 of the plaintext token. Unique so a lookup is a single\n  -- indexed equality probe and duplicate mints are impossible.\n  token_hash text NOT NULL UNIQUE,\n  -- Non-secret display fragment, e.g. \"nbmcp_a1b2c3d4\". Never enough to authenticate.\n  token_prefix text NOT NULL,\n  -- 'read' grants the read-only tools; 'write' additionally grants the mutating ones.\n  scopes text[] NOT NULL DEFAULT ARRAY['read', 'write']::text[],\n  created_by uuid REFERENCES auth.users (id) ON DELETE SET NULL,\n  created_at timestamptz NOT NULL DEFAULT now(),\n  last_used_at timestamptz,\n  expires_at timestamptz,\n  revoked_at timestamptz\n);\n\nCOMMENT ON TABLE public.mcp_access_tokens IS\n  'Bearer tokens for the Cortex AI MCP server at /api/mcp. Stores SHA-256 hashes only; plaintext is displayed once at mint time.';\n\nCREATE INDEX IF NOT EXISTS mcp_access_tokens_token_hash_idx\n  ON public.mcp_access_tokens (token_hash);\n\n-- Orders the admin token list newest-first without a sort.\nCREATE INDEX IF NOT EXISTS mcp_access_tokens_created_at_idx\n  ON public.mcp_access_tokens (created_at DESC);\n\nALTER TABLE public.mcp_access_tokens ENABLE ROW LEVEL SECURITY;\n\n-- Tokens are credentials: admin-only, with no anon or WRITER access at all. The\n-- MCP route verifies them with the service-role client, which bypasses RLS.\nDROP POLICY IF EXISTS mcp_access_tokens_admin_select ON public.mcp_access_tokens;\nCREATE POLICY mcp_access_tokens_admin_select ON public.mcp_access_tokens\n  FOR SELECT TO authenticated\n  USING ((SELECT public.get_current_user_role()) = 'ADMIN'::public.user_role);\n\nDROP POLICY IF EXISTS mcp_access_tokens_admin_insert ON public.mcp_access_tokens;\nCREATE POLICY mcp_access_tokens_admin_insert ON public.mcp_access_tokens\n  FOR INSERT TO authenticated\n  WITH CHECK ((SELECT public.get_current_user_role()) = 'ADMIN'::public.user_role);\n\nDROP POLICY IF EXISTS mcp_access_tokens_admin_update ON public.mcp_access_tokens;\nCREATE POLICY mcp_access_tokens_admin_update ON public.mcp_access_tokens\n  FOR UPDATE TO authenticated\n  USING ((SELECT public.get_current_user_role()) = 'ADMIN'::public.user_role)\n  WITH CHECK ((SELECT public.get_current_user_role()) = 'ADMIN'::public.user_role);\n\nDROP POLICY IF EXISTS mcp_access_tokens_admin_delete ON public.mcp_access_tokens;\nCREATE POLICY mcp_access_tokens_admin_delete ON public.mcp_access_tokens\n  FOR DELETE TO authenticated\n  USING ((SELECT public.get_current_user_role()) = 'ADMIN'::public.user_role);\n\nGRANT SELECT, INSERT, UPDATE, DELETE ON public.mcp_access_tokens TO authenticated;\nGRANT ALL ON public.mcp_access_tokens TO service_role;\n\n-- Add cortex_ai_mcp_settings to the admin-only site_settings group (all four policies).\nDROP POLICY IF EXISTS site_settings_read_policy ON public.site_settings;\nCREATE POLICY site_settings_read_policy ON public.site_settings FOR SELECT USING (((key <> ALL (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) OR ((key = ANY (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) AND (( SELECT auth.role() AS role) = 'authenticated'::text) AND (( SELECT public.get_current_user_role() AS get_current_user_role) = 'ADMIN'::public.user_role))));\n\nDROP POLICY IF EXISTS site_settings_insert_policy ON public.site_settings;\nCREATE POLICY site_settings_insert_policy ON public.site_settings FOR INSERT TO authenticated WITH CHECK ((((key <> ALL (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'language_detection_settings'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) AND (( SELECT public.get_current_user_role() AS get_current_user_role) = ANY (ARRAY['ADMIN'::public.user_role, 'WRITER'::public.user_role]))) OR ((key = ANY (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'language_detection_settings'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) AND (( SELECT public.get_current_user_role() AS get_current_user_role) = 'ADMIN'::public.user_role))));\n\nDROP POLICY IF EXISTS site_settings_update_policy ON public.site_settings;\nCREATE POLICY site_settings_update_policy ON public.site_settings FOR UPDATE TO authenticated USING ((((key <> ALL (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'language_detection_settings'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) AND (( SELECT public.get_current_user_role() AS get_current_user_role) = ANY (ARRAY['ADMIN'::public.user_role, 'WRITER'::public.user_role]))) OR ((key = ANY (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'language_detection_settings'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) AND (( SELECT public.get_current_user_role() AS get_current_user_role) = 'ADMIN'::public.user_role)))) WITH CHECK ((((key <> ALL (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'language_detection_settings'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) AND (( SELECT public.get_current_user_role() AS get_current_user_role) = ANY (ARRAY['ADMIN'::public.user_role, 'WRITER'::public.user_role]))) OR ((key = ANY (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'language_detection_settings'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) AND (( SELECT public.get_current_user_role() AS get_current_user_role) = 'ADMIN'::public.user_role))));\n\nDROP POLICY IF EXISTS site_settings_delete_policy ON public.site_settings;\nCREATE POLICY site_settings_delete_policy ON public.site_settings FOR DELETE TO authenticated USING ((((key <> ALL (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'language_detection_settings'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) AND (( SELECT public.get_current_user_role() AS get_current_user_role) = ANY (ARRAY['ADMIN'::public.user_role, 'WRITER'::public.user_role]))) OR ((key = ANY (ARRAY['cortex_ai_openrouter_api_key'::text, 'bot_protection_secret'::text, 'email_secret'::text, 'payment_secret'::text, 'language_detection_settings'::text, 'cortex_ai_pexels_api_key'::text, 'cortex_ai_unsplash_access_key'::text, 'cortex_ai_mcp_settings'::text])) AND (( SELECT public.get_current_user_role() AS get_current_user_role) = 'ADMIN'::public.user_role))));\n"
   }
 ];

package/templates/nextblock-template/next-env.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
-import "./.next/dev/types/root-params.d.ts";
+import "./.next/types/routes.d.ts";
+import "./.next/types/root-params.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/templates/nextblock-template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextblock-cms/template",
-  "version": "0.14.5",
+  "version": "0.14.6",
   "private": true,
   "scripts": {
     "dev": "next dev",