@agent-native/core 0.101.7 → 0.101.10

package/corpus/templates/content/actions/preview-builder-source-review.ts

@@ -0,0 +1,99 @@
+import { defineAction } from "@agent-native/core";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import type {
+  PreviewBuilderSourceReviewRequest,
+  PreviewBuilderSourceReviewResponse,
+} from "../shared/api.js";
+import {
+  getContentDatabaseSourceSnapshotForWrite,
+  resolveDatabaseForSourceMutation,
+} from "./_database-source-utils.js";
+import {
+  BUILDER_SOURCE_REVIEW_PREPARE_LIMIT,
+  buildBuilderSourceReviewPayload,
+  reviewPreparePriority,
+  withAuthoritativeBuilderTargetRows,
+} from "./prepare-builder-source-review.js";
+
+export default defineAction({
+  description:
+    "Preview complete Builder CMS review diffs, including document body changes, without approving or writing anything.",
+  schema: z.object({
+    databaseId: z.string().optional().describe("Database ID"),
+    documentId: z.string().optional().describe("Database document/page ID"),
+    sourceId: z.string().optional().describe("Specific Builder source ID"),
+    scope: z.enum(["selected", "all"]).optional().default("all"),
+    documentIds: z
+      .array(z.string())
+      .max(BUILDER_SOURCE_REVIEW_PREPARE_LIMIT)
+      .optional()
+      .describe("Optional selected document IDs that bound the preview"),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (
+    args: PreviewBuilderSourceReviewRequest,
+  ): Promise<PreviewBuilderSourceReviewResponse> => {
+    const database = await resolveDatabaseForSourceMutation(args);
+    if (!database) throw new Error("Database not found.");
+    await assertAccess("document", database.documentId, "editor");
+
+    const source = await getContentDatabaseSourceSnapshotForWrite(
+      database,
+      args.sourceId,
+    );
+    if (!source || source.sourceType !== "builder-cms") {
+      throw new Error("Attach a Builder CMS source before reviewing updates.");
+    }
+
+    const selectedDocumentIds = new Set(args.documentIds ?? []);
+    if (args.scope === "selected" && selectedDocumentIds.size === 0) {
+      throw new Error("Select at least one Builder row before reviewing it.");
+    }
+    const allReviewableChanges = source.changeSets.filter((changeSet) => {
+      if (
+        changeSet.direction !== "outbound" ||
+        (changeSet.state !== "pending_push" &&
+          changeSet.state !== "staged_revision" &&
+          changeSet.state !== "approved")
+      ) {
+        return false;
+      }
+      return (
+        args.scope === "all" ||
+        (!!changeSet.documentId &&
+          selectedDocumentIds.has(changeSet.documentId))
+      );
+    });
+    const changeSets = [...allReviewableChanges]
+      .sort(
+        (left, right) =>
+          reviewPreparePriority(left) - reviewPreparePriority(right),
+      )
+      .slice(0, BUILDER_SOURCE_REVIEW_PREPARE_LIMIT);
+    const authoritativeSource = await withAuthoritativeBuilderTargetRows({
+      source,
+      changeSets,
+    });
+    const review =
+      changeSets.length > 0
+        ? buildBuilderSourceReviewPayload({
+            source: authoritativeSource,
+            changeSets,
+          })
+        : null;
+    if (review) {
+      review.totalRowCount = allReviewableChanges.length;
+      review.preparedRowLimit = changeSets.length;
+    }
+
+    return {
+      sourceId: source.id,
+      sourceTable: source.sourceTable,
+      changeSetIds: changeSets.map((changeSet) => changeSet.id),
+      review,
+    };
+  },
+});

package/corpus/templates/content/actions/set-content-database-source-write-mode.ts

@@ -38,7 +38,7 @@ function executableWriteModes(
 
 export default defineAction({
   description:
-    "Set the tiered Builder CMS write mode for one source. Writes stay off by default and can only be enabled for the safe Builder test collection.",
+    "Set the tiered Builder CMS write mode for one source. Writes stay off by default and require document administrator access to enable or change.",
   schema: z.object({
     databaseId: z.string().optional().describe("Database ID"),
     documentId: z.string().optional().describe("Database document/page ID"),
@@ -79,7 +79,7 @@ export default defineAction({
   ): Promise<ContentDatabaseResponse> => {
     const database = await resolveDatabaseForSourceMutation(args);
     if (!database) throw new Error("Database not found.");
-    await assertAccess("document", database.documentId, "editor");
+    await assertAccess("document", database.documentId, "admin");
 
     const db = getDb();
     const source = await getExistingSourceForWrite(database.id, args.sourceId);

package/corpus/templates/content/actions/update-preview-document-draft.ts

@@ -0,0 +1,153 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { readPreviewDocumentDraft } from "./_preview-document-draft.js";
+
+const draftPayload = z.object({
+  title: z.string().max(10_000),
+  content: z.string().max(500_000),
+  baseDocumentUpdatedAt: z.string().max(100).nullable(),
+  loadedContentWasEmpty: z.boolean(),
+  deferredReason: z.enum(["hydration", "conflict"]).nullable(),
+});
+
+function draftId() {
+  return crypto.randomUUID();
+}
+
+export default defineAction({
+  description:
+    "Atomically save or delete the current user's private preview draft.",
+  schema: z.discriminatedUnion("operation", [
+    z.object({
+      operation: z.literal("upsert"),
+      documentId: z.string().min(1),
+      expectedVersion: z.number().int().positive().nullable(),
+      draft: draftPayload,
+    }),
+    z.object({
+      operation: z.literal("delete"),
+      documentId: z.string().min(1),
+      expectedVersion: z.number().int().positive(),
+      expectedTitle: z.string().max(10_000),
+      expectedContent: z.string().max(500_000),
+    }),
+  ]),
+  agentTool: false,
+  toolCallable: false,
+  run: async (args, ctx) => {
+    const userEmail = getRequestUserEmail();
+    const orgId = getRequestOrgId() ?? "";
+    if (!userEmail) throw new Error("Not authenticated.");
+    await assertAccess("document", args.documentId, "editor");
+    const db = getDb();
+    const ownerFilter = and(
+      eq(schema.documentPreviewDrafts.ownerEmail, userEmail),
+      eq(schema.documentPreviewDrafts.orgId, orgId),
+      eq(schema.documentPreviewDrafts.documentId, args.documentId),
+    );
+
+    if (args.operation === "delete") {
+      const deleted = await db
+        .delete(schema.documentPreviewDrafts)
+        .where(
+          and(
+            ownerFilter,
+            eq(schema.documentPreviewDrafts.version, args.expectedVersion),
+            eq(schema.documentPreviewDrafts.title, args.expectedTitle),
+            eq(schema.documentPreviewDrafts.content, args.expectedContent),
+          ),
+        )
+        .returning({ id: schema.documentPreviewDrafts.id });
+      if (deleted.length > 0)
+        return { status: "deleted" as const, draft: null };
+      return {
+        status: "conflict" as const,
+        draft: await readPreviewDocumentDraft(
+          userEmail,
+          orgId,
+          args.documentId,
+        ),
+      };
+    }
+
+    const now = new Date().toISOString();
+    if (args.expectedVersion === null) {
+      const inserted = await db
+        .insert(schema.documentPreviewDrafts)
+        .values({
+          id: draftId(),
+          ownerEmail: userEmail,
+          orgId,
+          documentId: args.documentId,
+          title: args.draft.title,
+          content: args.draft.content,
+          baseDocumentUpdatedAt: args.draft.baseDocumentUpdatedAt,
+          loadedContentWasEmpty: args.draft.loadedContentWasEmpty ? 1 : 0,
+          deferredReason: args.draft.deferredReason,
+          version: 1,
+          createdAt: now,
+          updatedAt: now,
+        })
+        .onConflictDoNothing({
+          target: [
+            schema.documentPreviewDrafts.ownerEmail,
+            schema.documentPreviewDrafts.orgId,
+            schema.documentPreviewDrafts.documentId,
+          ],
+        })
+        .returning({ version: schema.documentPreviewDrafts.version });
+      if (inserted.length > 0) {
+        return {
+          status: "saved" as const,
+          draft: await readPreviewDocumentDraft(
+            userEmail,
+            orgId,
+            args.documentId,
+          ),
+        };
+      }
+    } else {
+      const updated = await db
+        .update(schema.documentPreviewDrafts)
+        .set({
+          title: args.draft.title,
+          content: args.draft.content,
+          baseDocumentUpdatedAt: args.draft.baseDocumentUpdatedAt,
+          loadedContentWasEmpty: args.draft.loadedContentWasEmpty ? 1 : 0,
+          deferredReason: args.draft.deferredReason,
+          version: sql`${schema.documentPreviewDrafts.version} + 1`,
+          updatedAt: now,
+        })
+        .where(
+          and(
+            ownerFilter,
+            eq(schema.documentPreviewDrafts.version, args.expectedVersion),
+          ),
+        )
+        .returning({ version: schema.documentPreviewDrafts.version });
+      if (updated.length > 0) {
+        return {
+          status: "saved" as const,
+          draft: await readPreviewDocumentDraft(
+            userEmail,
+            orgId,
+            args.documentId,
+          ),
+        };
+      }
+    }
+
+    return {
+      status: "conflict" as const,
+      draft: await readPreviewDocumentDraft(userEmail, orgId, args.documentId),
+    };
+  },
+});

package/corpus/templates/content/app/components/editor/DocumentProperties.tsx

@@ -489,6 +489,24 @@ export function filesMediaEditorValue(value: DocumentProperty["value"]) {
   return filesMediaItems(value).join("\n");
 }
 
+export function isValidFilesMediaLink(value: string) {
+  try {
+    const url = new URL(value.trim());
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+export function mergeFilesMediaItems(items: string[], pendingLink: string) {
+  const trimmed = pendingLink.trim();
+  if (!trimmed || !isValidFilesMediaLink(trimmed)) return items;
+  if (items.some((item) => item.toLowerCase() === trimmed.toLowerCase())) {
+    return items;
+  }
+  return [...items, trimmed];
+}
+
 export function filesMediaLabel(value: string) {
   const trimmed = value.trim();
   if (!trimmed) return "File";
@@ -2060,16 +2078,8 @@ function FilesMediaValueEditor({
   }, []);
 
   function addItem(value: string) {
-    const trimmed = value.trim();
-    if (!trimmed) return;
-    setItems((current) => {
-      if (
-        current.some((item) => item.toLowerCase() === trimmed.toLowerCase())
-      ) {
-        return current;
-      }
-      return [...current, trimmed];
-    });
+    if (!isValidFilesMediaLink(value)) return;
+    setItems((current) => mergeFilesMediaItems(current, value));
     setLinkValue("");
   }
 
@@ -2126,11 +2136,11 @@ function FilesMediaValueEditor({
       className="grid gap-3"
       onSubmit={(event) => {
         event.preventDefault();
-        if (linkValue.trim()) {
-          addItem(linkValue);
+        if (linkValue.trim() && !isValidFilesMediaLink(linkValue)) {
+          linkInputRef.current?.reportValidity();
           return;
         }
-        void save();
+        void save(mergeFilesMediaItems(items, linkValue));
       }}
     >
       <div className="grid max-h-48 gap-1 overflow-auto">
@@ -2174,9 +2184,11 @@ function FilesMediaValueEditor({
       <div className="flex gap-1">
         <Input
           ref={linkInputRef}
-          aria-label={t("editor.properties.addPropertyLink", {
+          aria-label={t("editor.properties.editValue", {
             name: property.definition.name,
           })}
+          type="url"
+          pattern="[hH][tT][tT][pP][sS]?://.*"
           value={linkValue}
           placeholder={t("editor.properties.pasteFileOrMediaLink")}
           onChange={(event) => setLinkValue(event.target.value)}
@@ -2193,7 +2205,7 @@ function FilesMediaValueEditor({
           size="sm"
           className="shrink-0"
           onClick={() => addItem(linkValue)}
-          disabled={!linkValue.trim() || mutation.isPending}
+          disabled={!isValidFilesMediaLink(linkValue) || mutation.isPending}
         >
           <IconPlus className="size-3.5" />
           {t("editor.properties.add")}

package/corpus/templates/content/app/components/editor/VisualEditor.tsx

@@ -924,6 +924,28 @@ export function shouldPersistLocalFileEditorUpdate({
   return Boolean(transactionUiEvent);
 }
 
+function isEffectivelyEmptyEditorContent(value: string): boolean {
+  const normalized = value.trim();
+  return normalized === "" || normalized === "<empty-block/>";
+}
+
+export function shouldPersistEffectivelyEmptyEditorUpdate({
+  nextContent,
+  userInitiated,
+}: {
+  nextContent: string;
+  userInitiated: boolean;
+}): boolean {
+  if (!isEffectivelyEmptyEditorContent(nextContent)) return true;
+  // Empty editor state is never worth persisting without a user gesture. This
+  // also covers the preview remount window where `content` can briefly be an
+  // empty list snapshot even though its retained save controller still has a
+  // rich confirmed baseline. Comparing only to this render's prop would let
+  // that mount-time filler mark the retained controller dirty and its
+  // flush-on-release path would then overwrite SQL.
+  return userInitiated;
+}
+
 function isActiveSlashCommandDraft(editor: CoreEditor): boolean {
   const { state } = editor;
   if (!state.selection.empty) return false;
@@ -1086,7 +1108,9 @@ function getVisualEditorPlaceholder({
     if (level === 1) return "Heading 1";
     if (level === 2) return "Heading 2";
     if (level === 3) return "Heading 3";
-    return "Heading 4";
+    if (level === 4) return "Heading 4";
+    if (level === 5) return "Heading 5";
+    return "Heading 6";
   }
 
   if (
@@ -1300,6 +1324,7 @@ export function createVisualEditorExtensions({
     starterKit: {
       blockquote: false,
       paragraph: false,
+      heading: { levels: [1, 2, 3, 4, 5, 6] },
       horizontalRule: {},
       dropcursor: { color: false, width: 3, class: "notion-dropcursor" },
     },
@@ -1742,7 +1767,11 @@ export function VisualEditor({
   const persistEditorContent = useCallback(
     (
       editorToPersist: CoreEditor,
-      options?: { markdown?: string; immediate?: boolean },
+      options?: {
+        markdown?: string;
+        immediate?: boolean;
+        userInitiated?: boolean;
+      },
     ) => {
       const guards = guardsRef.current;
       if (!guards) return false;
@@ -1750,6 +1779,20 @@ export function VisualEditor({
         const normalized =
           options?.markdown ?? docToNfm(editorToPersist.getJSON() as any);
         if (localFileMode && normalized === content) return true;
+        // TipTap/Yjs can emit a local-looking empty-paragraph transaction while
+        // an editor is mounting or reconciling. Content serializes that filler
+        // as `<empty-block/>`, so the generic whitespace-only collab guard does
+        // not catch it. Never let that lifecycle normalization clear a saved
+        // body. A real Select All/Delete (or Cut) records user intent through
+        // the DOM handlers below and is still allowed to persist normally.
+        if (
+          !shouldPersistEffectivelyEmptyEditorUpdate({
+            nextContent: normalized,
+            userInitiated: options?.userInitiated === true,
+          })
+        ) {
+          return true;
+        }
         if (options?.immediate && onSaveContentRef.current) {
           return onSaveContentRef.current(normalized);
         }
@@ -1923,7 +1966,12 @@ export function VisualEditor({
         return;
       }
       if (isActiveSlashCommandDraft(editor)) return;
-      persistEditorContent(editor);
+      persistEditorContent(editor, {
+        userInitiated:
+          transaction.getMeta(LOCAL_FILE_USER_EDIT_META) === true ||
+          Date.now() - lastUserEditIntentAtRef.current < 2000 ||
+          Boolean(transaction.getMeta("uiEvent")),
+      });
     },
   });
 
@@ -2239,10 +2287,14 @@ export function VisualEditor({
           documentId={documentId}
           notionPageId={notionPageId}
           onDraftCommitted={() => {
-            void persistEditorContent(editor);
+            void persistEditorContent(editor, { userInitiated: true });
           }}
           onDraftPersisted={(markdown) =>
-            persistEditorContent(editor, { markdown, immediate: true })
+            persistEditorContent(editor, {
+              markdown,
+              immediate: true,
+              userInitiated: true,
+            })
           }
         />
       ) : null}

package/corpus/templates/content/app/components/editor/body-hydration.ts

@@ -89,6 +89,33 @@ export function previewBodyHydrationIsPending(args: {
   );
 }
 
+/**
+ * A draft that began from an empty source snapshot must not automatically
+ * replace a non-empty Builder body that arrived while hydration was running.
+ * Keep the draft dirty/recoverable and let the user decide which body to keep.
+ */
+export function previewDraftConflictsWithHydratedBody(args: {
+  loadedContent: string | null | undefined;
+  loadedUpdatedAt: string | null | undefined;
+  loadedContentWasEmpty: boolean | undefined;
+  pendingContent: string | null | undefined;
+  hydratedContent: string | null | undefined;
+  hydratedUpdatedAt: string | null | undefined;
+}) {
+  const sourceChangedSinceDraftLoaded =
+    (!!args.loadedUpdatedAt &&
+      !!args.hydratedUpdatedAt &&
+      args.loadedUpdatedAt !== args.hydratedUpdatedAt) ||
+    args.loadedContent !== args.hydratedContent;
+  return (
+    !isEffectivelyEmptyDocumentContent(args.pendingContent) &&
+    args.pendingContent !== args.hydratedContent &&
+    sourceChangedSinceDraftLoaded &&
+    (args.loadedContentWasEmpty === true ||
+      args.loadedContent !== args.hydratedContent)
+  );
+}
+
 export function previewBodyHydrationIsTerminalError(args: {
   item: Pick<ContentDatabaseItem, "bodyHydration" | "document">;
   document: Pick<Document, "databaseMembership"> | null | undefined;