@agent-native/core 0.77.10 → 0.77.12

package/corpus/templates/content/actions/move-document.ts

@@ -1,6 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
-import { assertAccess } from "@agent-native/core/sharing";
+import { assertAccess, type Visibility } from "@agent-native/core/sharing";
 import { and, eq, sql } from "drizzle-orm";
 import { z } from "zod";
 
@@ -54,19 +54,17 @@ async function assertParentIsNotDescendant({
   }
 }
 
-async function clearBlockDatabaseOwnershipAfterParentChange({
+async function preflightBlockDatabaseOwnershipClearance({
   db,
   documentId,
   ownerEmail,
   parentId,
-  updatedAt,
 }: {
   db: ReturnType<typeof getDb>;
   documentId: string;
   ownerEmail: string;
   parentId: string | null;
-  updatedAt: string;
-}) {
+}): Promise<string | null> {
   const [database] = await db
     .select({
       id: schema.contentDatabases.id,
@@ -81,11 +79,24 @@ async function clearBlockDatabaseOwnershipAfterParentChange({
     );
 
   if (!database?.ownerDocumentId || database.ownerDocumentId === parentId) {
-    return;
+    return null;
   }
 
   await assertAccess("document", database.ownerDocumentId, "editor");
+  return database.id;
+}
 
+async function clearBlockDatabaseOwnership({
+  db,
+  databaseId,
+  ownerEmail,
+  updatedAt,
+}: {
+  db: Pick<ReturnType<typeof getDb>, "update">;
+  databaseId: string;
+  ownerEmail: string;
+  updatedAt: string;
+}) {
   await db
     .update(schema.contentDatabases)
     .set({
@@ -95,23 +106,44 @@ async function clearBlockDatabaseOwnershipAfterParentChange({
     })
     .where(
       and(
-        eq(schema.contentDatabases.id, database.id),
+        eq(schema.contentDatabases.id, databaseId),
         eq(schema.contentDatabases.ownerEmail, ownerEmail),
       ),
     );
 }
 
+function sameRootSection(
+  left: { visibility: Visibility; orgId?: string | null },
+  right: { visibility: Visibility; orgId?: string | null },
+) {
+  return left.visibility === right.visibility && left.orgId === right.orgId;
+}
+
+function rootSectionFilter(document: {
+  visibility: Visibility;
+  orgId?: string | null;
+}) {
+  return and(
+    eq(schema.documents.visibility, document.visibility),
+    document.orgId
+      ? eq(schema.documents.orgId, document.orgId)
+      : sql`${schema.documents.orgId} IS NULL`,
+  );
+}
+
 async function resolveSiblingPositionsAfterMove({
   db,
   ownerEmail,
   id,
   parentId,
+  rootSection,
   position,
 }: {
   db: ReturnType<typeof getDb>;
   ownerEmail: string;
   id: string;
   parentId: string | null;
+  rootSection: { visibility: Visibility; orgId?: string | null };
   position: number;
 }) {
   const siblings = await db
@@ -129,6 +161,7 @@ async function resolveSiblingPositionsAfterMove({
           )
         : and(
             eq(schema.documents.ownerEmail, ownerEmail),
+            rootSectionFilter(rootSection),
             sql`parent_id IS NULL`,
           ),
     );
@@ -209,6 +242,9 @@ export default defineAction({
         if (parentAccess.resource.ownerEmail !== ownerEmail) {
           throw new Error("Parent document must belong to the same owner");
         }
+        if (!sameRootSection(parentAccess.resource, existing)) {
+          throw new Error("Parent document must be in the same section");
+        }
         await assertParentIsNotDescendant({
           db,
           ownerEmail,
@@ -221,6 +257,15 @@ export default defineAction({
 
     const targetParentId =
       args.parentId !== undefined ? args.parentId : existing.parentId;
+    const blockDatabaseIdToDetach =
+      args.parentId !== undefined
+        ? await preflightBlockDatabaseOwnershipClearance({
+            db,
+            documentId: id,
+            ownerEmail,
+            parentId: args.parentId,
+          })
+        : null;
     const normalizedSiblingPositions =
       args.position !== undefined
         ? await resolveSiblingPositionsAfterMove({
@@ -228,6 +273,7 @@ export default defineAction({
             ownerEmail,
             id,
             parentId: targetParentId,
+            rootSection: existing,
             position: args.position,
           })
         : null;
@@ -249,36 +295,36 @@ export default defineAction({
               )
             : and(
                 eq(schema.documents.ownerEmail, ownerEmail),
+                rootSectionFilter(existing),
                 sql`parent_id IS NULL`,
               ),
         );
       updates.position = (maxPos[0]?.max ?? -1) + 1;
     }
 
-    await db
-      .update(schema.documents)
-      .set(updates)
-      .where(
-        and(
-          eq(schema.documents.id, id),
-          eq(schema.documents.ownerEmail, ownerEmail),
-        ),
-      );
+    await db.transaction(async (tx) => {
+      await tx
+        .update(schema.documents)
+        .set(updates)
+        .where(
+          and(
+            eq(schema.documents.id, id),
+            eq(schema.documents.ownerEmail, ownerEmail),
+          ),
+        );
 
-    if (args.parentId !== undefined) {
-      await clearBlockDatabaseOwnershipAfterParentChange({
-        db,
-        documentId: id,
-        ownerEmail,
-        parentId: args.parentId,
-        updatedAt,
-      });
-    }
+      if (args.parentId !== undefined && blockDatabaseIdToDetach) {
+        await clearBlockDatabaseOwnership({
+          db: tx,
+          databaseId: blockDatabaseIdToDetach,
+          ownerEmail,
+          updatedAt,
+        });
+      }
 
-    if (normalizedSiblingPositions) {
-      await Promise.all(
-        normalizedSiblingPositions.map((document) =>
-          db
+      if (normalizedSiblingPositions) {
+        for (const document of normalizedSiblingPositions) {
+          await tx
             .update(schema.documents)
             .set({ position: document.position })
             .where(
@@ -286,10 +332,10 @@ export default defineAction({
                 eq(schema.documents.id, document.id),
                 eq(schema.documents.ownerEmail, ownerEmail),
               ),
-            ),
-        ),
-      );
-    }
+            );
+        }
+      }
+    });
 
     const [doc] = await db
       .select()

package/corpus/templates/content/actions/restore-content-database.ts

@@ -1,10 +1,37 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
+import { resolveAccess } from "@agent-native/core/sharing";
 import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { assertContentDatabaseLifecycleAccess } from "./_content-database-lifecycle.js";
+import {
+  assertContentDatabaseLifecycleAccess,
+  collectInlineDatabaseOwnerBlockIds,
+} from "./_content-database-lifecycle.js";
+import pullDocumentAction from "./pull-document.js";
+
+async function shouldClearStaleInlineOwnership(args: {
+  ownerDocumentId: string | null;
+  ownerBlockId: string | null;
+}) {
+  if (!args.ownerDocumentId || !args.ownerBlockId) return false;
+  let content: string | null = null;
+  try {
+    const host = await pullDocumentAction.run({
+      id: args.ownerDocumentId,
+      format: "markdown",
+    });
+    content = String(host.content ?? "");
+  } catch {
+    const hostAccess = await resolveAccess("document", args.ownerDocumentId);
+    if (!hostAccess) return false;
+    content = String(hostAccess.resource.content ?? "");
+  }
+
+  const parsed = await collectInlineDatabaseOwnerBlockIds(content);
+  return parsed.ok && !parsed.ownerBlockIds.has(args.ownerBlockId);
+}
 
 export default defineAction({
   description: "Restore a soft-deleted content database.",
@@ -12,13 +39,23 @@ export default defineAction({
     databaseId: z.string().describe("Content database ID"),
   }),
   run: async ({ databaseId }) => {
-    await assertContentDatabaseLifecycleAccess(databaseId);
+    const ownership = await assertContentDatabaseLifecycleAccess(databaseId);
     const db = getDb();
     const now = new Date().toISOString();
+    const clearInlineOwnership = await shouldClearStaleInlineOwnership({
+      ownerDocumentId: ownership.database.ownerDocumentId,
+      ownerBlockId: ownership.database.ownerBlockId,
+    });
 
     await db
       .update(schema.contentDatabases)
-      .set({ deletedAt: null, updatedAt: now })
+      .set({
+        deletedAt: null,
+        updatedAt: now,
+        ...(clearInlineOwnership
+          ? { ownerDocumentId: null, ownerBlockId: null }
+          : {}),
+      })
       .where(eq(schema.contentDatabases.id, databaseId));
 
     await writeAppState("refresh-signal", { ts: Date.now() });

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

@@ -11,10 +11,16 @@ import {
   IconH3,
   IconH4,
 } from "@tabler/icons-react";
-import { NodeSelection, type EditorState } from "@tiptap/pm/state";
+import {
+  NodeSelection,
+  Plugin,
+  PluginKey,
+  type EditorState,
+} from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
 import type { Editor } from "@tiptap/react";
 import { BubbleMenu } from "@tiptap/react/menus";
-import { useState } from "react";
+import { useEffect, useState } from "react";
 
 import {
   Tooltip,
@@ -44,6 +50,15 @@ const BUBBLE_TOOLBAR_EXCLUDED_NODE_TYPES = new Set([
   "localMdxComponent",
 ]);
 
+type SelectionFillRange = {
+  from: number;
+  to: number;
+};
+
+const selectionFillPluginKey = new PluginKey<SelectionFillRange | null>(
+  "contentSelectionFill",
+);
+
 function selectionIncludesBubbleToolbarExcludedNode(
   state: EditorState,
   from: number,
@@ -72,6 +87,73 @@ export function BubbleToolbar({ editor, onComment }: BubbleToolbarProps) {
   const [showLinkInput, setShowLinkInput] = useState(false);
   const [linkUrl, setLinkUrl] = useState("");
 
+  useEffect(() => {
+    const plugin = new Plugin<SelectionFillRange | null>({
+      key: selectionFillPluginKey,
+      state: {
+        init: () => null,
+        apply: (tr, value) => {
+          const meta = tr.getMeta(selectionFillPluginKey);
+          if (meta !== undefined) return meta;
+          return value
+            ? {
+                from: tr.mapping.map(value.from),
+                to: tr.mapping.map(value.to),
+              }
+            : null;
+        },
+      },
+      props: {
+        decorations(state) {
+          const range = selectionFillPluginKey.getState(state);
+          if (!range || range.from === range.to) return DecorationSet.empty;
+          return DecorationSet.create(state.doc, [
+            Decoration.inline(range.from, range.to, {
+              class: "notion-selection-fill",
+            }),
+          ]);
+        },
+      },
+    });
+
+    editor.registerPlugin(plugin);
+
+    const syncSelectionFill = () => {
+      const { state } = editor;
+      const { from, to } = state.selection;
+      const nextRange =
+        editor.isFocused &&
+        from !== to &&
+        !selectionIncludesBubbleToolbarExcludedNode(state, from, to)
+          ? { from, to }
+          : null;
+      const currentRange = selectionFillPluginKey.getState(state);
+      if (
+        currentRange?.from === nextRange?.from &&
+        currentRange?.to === nextRange?.to
+      ) {
+        return;
+      }
+      editor.view.dispatch(
+        state.tr
+          .setMeta(selectionFillPluginKey, nextRange)
+          .setMeta("addToHistory", false),
+      );
+    };
+
+    editor.on("selectionUpdate", syncSelectionFill);
+    editor.on("focus", syncSelectionFill);
+    editor.on("blur", syncSelectionFill);
+    syncSelectionFill();
+
+    return () => {
+      editor.off("selectionUpdate", syncSelectionFill);
+      editor.off("focus", syncSelectionFill);
+      editor.off("blur", syncSelectionFill);
+      editor.unregisterPlugin(selectionFillPluginKey);
+    };
+  }, [editor]);
+
   const handleSetLink = () => {
     if (linkUrl.trim()) {
       editor