@agent-native/core 0.114.0 → 0.114.1

package/corpus/templates/content/actions/set-document-property.ts

@@ -13,11 +13,12 @@ import {
   parsePropertyOptions,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { resolveContentDocumentAccess } from "./_content-document-access.js";
 import {
-  listPropertiesForDocument,
+  getDatabaseById,
+  listPropertiesForDatabaseDocuments,
   nanoid,
   normalizedValueJson,
-  resolvePropertyDatabaseForDocument,
   writeBlockFieldContent,
   writePrimaryBlocksContent,
 } from "./_property-utils.js";
@@ -30,27 +31,34 @@ export default defineAction({
     value: z.unknown().describe("Value for the property type"),
   }),
   run: async ({ documentId, propertyId, value }) => {
-    const access = await assertAccess("document", documentId, "editor");
-    const document = access.resource;
     const db = getDb();
-    const database = await resolvePropertyDatabaseForDocument(document);
-    if (!database) throw new Error("Document is not part of a database.");
-
     const [definition] = await db
       .select()
       .from(schema.documentPropertyDefinitions)
+      .where(eq(schema.documentPropertyDefinitions.id, propertyId));
+    if (!definition) throw new Error(`Property "${propertyId}" not found`);
+    if (!definition.databaseId) {
+      throw new Error(`Property "${propertyId}" is not attached to a database`);
+    }
+    const database = await getDatabaseById(definition.databaseId);
+    if (!database) throw new Error("Document database not found.");
+    await assertAccess("document", database.documentId, "editor");
+    if (definition.systemRole) {
+      throw new Error("System properties are derived and cannot be edited.");
+    }
+    const access = await resolveContentDocumentAccess(documentId);
+    if (!access) throw new Error(`Document "${documentId}" not found`);
+    const document = access.resource;
+    const [membership] = await db
+      .select({ id: schema.contentDatabaseItems.id })
+      .from(schema.contentDatabaseItems)
       .where(
         and(
-          eq(schema.documentPropertyDefinitions.id, propertyId),
-          eq(
-            schema.documentPropertyDefinitions.ownerEmail,
-            document.ownerEmail,
-          ),
-          eq(schema.documentPropertyDefinitions.databaseId, database.id),
+          eq(schema.contentDatabaseItems.databaseId, database.id),
+          eq(schema.contentDatabaseItems.documentId, documentId),
         ),
       );
-    if (!definition) throw new Error(`Property "${propertyId}" not found`);
-
+    if (!membership) throw new Error("Document is not part of this database.");
     const type = definition.type as DocumentPropertyType;
     if (isComputedPropertyType(type)) {
       throw new Error("Computed properties cannot be edited.");
@@ -62,6 +70,7 @@ export default defineAction({
     // primary "Content" field writes to the document body; additional Blocks
     // fields write to their own independent store.
     if (isBlocksPropertyType(type)) {
+      await assertAccess("document", documentId, "editor");
       const normalized = normalizePropertyValue(type, value);
       const content = typeof normalized === "string" ? normalized : "";
       const target = blocksStorageTarget(
@@ -73,7 +82,7 @@ export default defineAction({
         await writeBlockFieldContent({
           documentId,
           propertyId,
-          ownerEmail: document.ownerEmail,
+          ownerEmail: database.ownerEmail,
           content,
           now,
         });
@@ -82,11 +91,17 @@ export default defineAction({
       return {
         documentId,
         databaseId: database.id,
-        properties: await listPropertiesForDocument({
-          ...document,
-          content: target === "document_body" ? content : document.content,
-          updatedAt: now,
-        }),
+        properties:
+          (
+            await listPropertiesForDatabaseDocuments(database.id, [
+              {
+                ...document,
+                content:
+                  target === "document_body" ? content : document.content,
+                updatedAt: now,
+              },
+            ])
+          ).get(documentId) ?? [],
       };
     }
 
@@ -109,7 +124,7 @@ export default defineAction({
     } else {
       await db.insert(schema.documentPropertyValues).values({
         id: nanoid(),
-        ownerEmail: document.ownerEmail,
+        ownerEmail: database.ownerEmail,
         documentId,
         propertyId,
         valueJson,
@@ -123,7 +138,10 @@ export default defineAction({
     return {
       documentId,
       databaseId: database.id,
-      properties: await listPropertiesForDocument(document),
+      properties:
+        (await listPropertiesForDatabaseDocuments(database.id, [document])).get(
+          documentId,
+        ) ?? [],
     };
   },
 });

package/corpus/templates/content/actions/share-local-file-document.ts

@@ -13,6 +13,7 @@ import {
   parseDocumentFavorite,
   parseDocumentHideFromSearch,
 } from "../server/lib/documents.js";
+import { setFavoriteMembership } from "./_content-favorites.js";
 import { ensureDocumentFilesMembership } from "./_content-files.js";
 import {
   organizationContentSpaceId,
@@ -136,6 +137,13 @@ export default defineAction({
         .where(eq(schema.documents.id, existing.id));
 
       await ensureDocumentFilesMembership(db, existing.id, now);
+      await setFavoriteMembership({
+        db,
+        userEmail,
+        documentId: existing.id,
+        favorite: localDocument.isFavorite,
+        now,
+      });
 
       const [row] = await db
         .select()
@@ -182,6 +190,13 @@ export default defineAction({
           updatedAt: now,
         });
         await ensureDocumentFilesMembership(db, documentId, now);
+        await setFavoriteMembership({
+          db,
+          userEmail,
+          documentId,
+          favorite: localDocument.isFavorite,
+          now,
+        });
       },
     );
 

package/corpus/templates/content/actions/submit-content-database-form.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import type {
   ContentDatabaseView,
+  DocumentPropertySystemRole,
   SubmitContentDatabaseFormResponse,
 } from "../shared/api.js";
 import { contentDatabaseFormQuestions } from "../shared/database-form.js";
@@ -143,6 +144,11 @@ function resolveSubmittedProperties(
     }
     const definition = exact ?? named[0];
     if (!definition) throw new Error(`Unknown form property "${inputKey}".`);
+    if (definition.systemRole) {
+      throw new Error(
+        `System property "${definition.name}" cannot be submitted.`,
+      );
+    }
     if (!enabledPropertyIds.has(definition.id)) {
       throw new Error(
         `Property "${definition.name}" is not enabled in this form.`,
@@ -235,6 +241,7 @@ export default defineAction({
       definition: {
         id: definition.id,
         type: definition.type as DocumentPropertyType,
+        systemRole: definition.systemRole as DocumentPropertySystemRole | null,
       },
     }));
     const questions = contentDatabaseFormQuestions(formView, properties);

package/corpus/templates/content/actions/sync-local-folder-source.ts

@@ -14,8 +14,10 @@ import {
   isContentSourcePath,
   parseContentSourceFile,
 } from "../shared/content-source.js";
+import { setFavoriteMembership } from "./_content-favorites.js";
 import { ensureDocumentsFilesMembership } from "./_content-files.js";
 import { resolveContentSpaceAccess } from "./_content-space-access.js";
+import { provisionContentSpaces } from "./_content-spaces.js";
 import { LOCAL_FOLDER_SOURCE_TYPE } from "./_local-folder-source.js";
 
 const MAX_SOURCE_FILES = 500;
@@ -175,6 +177,7 @@ export default defineAction({
       throw new Error(`Local folder source "${sourceId}" not found`);
     }
     await resolveContentSpaceAccess(target.database.spaceId, "editor");
+    if (!dryRun) await provisionContentSpaces(db, userEmail);
     const targetSpaceId = target.database.spaceId;
 
     const parsed = entries.map(([path, value]) =>
@@ -572,6 +575,17 @@ export default defineAction({
           }
         }
 
+        for (const plan of plans) {
+          if (plan.conflict || plan.existing || !plan.file.isFavorite) continue;
+          await setFavoriteMembership({
+            db: tx,
+            userEmail,
+            documentId: plan.id,
+            favorite: true,
+            now,
+          });
+        }
+
         const materializedIds = plans
           .filter((plan) => !plan.conflict)
           .map((plan) => plan.id);

package/corpus/templates/content/actions/update-content-database-view.ts

@@ -76,6 +76,7 @@ const viewSchema = z.object({
       "form",
       "sidebar",
     ])
+    .transform((type) => (type === "sidebar" ? "table" : type))
     .default("table"),
   sorts: z.array(sortSchema).default([]),
   filters: z.array(filterSchema).default([]),

package/corpus/templates/content/actions/update-content-sidebar-state.ts

@@ -0,0 +1,27 @@
+import { defineAction } from "@agent-native/core/action";
+import { putUserSetting } from "@agent-native/core/settings";
+
+import {
+  CONTENT_SIDEBAR_STATE_SETTING_KEY,
+  contentSidebarStateSchema,
+} from "./_content-sidebar-state.js";
+
+export default defineAction({
+  description: "Persist the current user's Content sidebar expansion state.",
+  schema: contentSidebarStateSchema,
+  agentTool: false,
+  run: async (state, ctx) => {
+    if (!ctx?.userEmail) throw new Error("Not authenticated.");
+    const normalized = {
+      ...state,
+      expandedWorkspaceIds: [...new Set(state.expandedWorkspaceIds)],
+      expandedDocumentIds: [...new Set(state.expandedDocumentIds)],
+    };
+    await putUserSetting(
+      ctx.userEmail,
+      CONTENT_SIDEBAR_STATE_SETTING_KEY,
+      normalized,
+    );
+    return { state: normalized };
+  },
+});

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

@@ -1,6 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { agentTouchDocument } from "@agent-native/core/collab";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
 import {
   getGenerationCreativeContext,
@@ -9,7 +10,7 @@ import {
   validateGenerationCreativeContext,
 } from "@agent-native/creative-context/server";
 import type { CreativeContextReuseLabel } from "@agent-native/creative-context/types";
-import { and, eq, desc } from "drizzle-orm";
+import { and, eq, desc, inArray } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -20,6 +21,12 @@ import {
 import type { DocumentUpdateResponse } from "../shared/api.js";
 import { BUILDER_CMS_BODY_CONTENT_KEY } from "./_builder-cms-source-adapter.js";
 import { reconcileInlineDatabasesForDocument } from "./_content-database-lifecycle.js";
+import { resolveContentDocumentAccess } from "./_content-document-access.js";
+import {
+  favoriteDocumentIds,
+  setFavoriteMembership,
+} from "./_content-favorites.js";
+import { provisionContentSpaces } from "./_content-spaces.js";
 import { serializeDocumentSource } from "./_document-source.js";
 
 // Not (yet) part of the shared API surface — kept local to avoid touching
@@ -137,6 +144,10 @@ function canManageRole(role: string) {
   return role === "owner" || role === "admin";
 }
 
+function canEditRole(role: string) {
+  return role === "owner" || role === "admin" || role === "editor";
+}
+
 function builderBodyWithoutImageSourceComponentMarkers(
   content: string | null | undefined,
 ) {
@@ -304,11 +315,30 @@ export default defineAction({
     const isAgentCaller =
       ctx?.caller === "tool" || ctx?.caller === "mcp" || ctx?.caller === "a2a";
 
-    const access = await assertAccess("document", id, "editor");
+    const favoriteOnly =
+      args.isFavorite !== undefined &&
+      args.title === undefined &&
+      args.content === undefined &&
+      args.description === undefined &&
+      args.icon === undefined;
+    const access = favoriteOnly
+      ? await resolveContentDocumentAccess(id)
+      : await assertAccess("document", id, "editor");
+    if (!access) throw new Error(`Document "${id}" not found`);
     const existing = access.resource;
     const ownerEmail = existing.ownerEmail as string;
 
     const db = getDb();
+    const requestUserEmail = getRequestUserEmail();
+    if (args.isFavorite !== undefined && !requestUserEmail) {
+      throw new Error("no authenticated user");
+    }
+    if (args.isFavorite !== undefined) {
+      await provisionContentSpaces(db, requestUserEmail as string);
+    }
+    const currentFavorite = requestUserEmail
+      ? (await favoriteDocumentIds(db, requestUserEmail, [id])).has(id)
+      : parseDocumentFavorite(existing.isFavorite);
 
     // Strip leading H1 that duplicates the title
     let content = args.content;
@@ -383,11 +413,12 @@ export default defineAction({
       content !== undefined && content !== existing.content;
     const iconChanged = args.icon !== undefined && args.icon !== existing.icon;
     const favoriteChanged =
-      args.isFavorite !== undefined &&
-      (args.isFavorite ? 1 : 0) !== (existing.isFavorite ?? 0);
+      args.isFavorite !== undefined && args.isFavorite !== currentFavorite;
     const descriptionChanged =
       args.description !== undefined &&
       args.description.trim() !== existing.description;
+    const documentFieldsChanged =
+      titleChanged || contentChanged || iconChanged || descriptionChanged;
     const anyChange =
       titleChanged ||
       contentChanged ||
@@ -452,69 +483,127 @@ export default defineAction({
         updates.description = args.description.trim();
       if (contentChanged) updates.content = content;
       if (iconChanged) updates.icon = args.icon;
-      if (favoriteChanged) updates.isFavorite = args.isFavorite ? 1 : 0;
-
-      if (useContentCas) {
-        const applied = await db
-          .update(schema.documents)
-          .set(updates)
-          .where(
-            and(
-              eq(schema.documents.id, id),
-              eq(schema.documents.updatedAt, args.baseUpdatedAt as string),
-            ),
-          )
-          .returning({ id: schema.documents.id });
-
-        if (!applied || applied.length === 0) {
-          // Someone else's write landed after the caller's snapshot. Don't
-          // apply this save at all (title/icon/favorite included — a partial
-          // apply would desync the fields from what the caller believes it
-          // just sent) and hand back the current server row instead so the
-          // caller can reconcile.
-          const [current] = await db
-            .select()
-            .from(schema.documents)
-            .where(eq(schema.documents.id, id));
-          return {
-            conflict: true,
-            id,
-            document: {
-              id: current.id,
-              urlPath: `/page/${current.id}`,
-              parentId: current.parentId,
-              title: current.title,
-              content: current.content,
-              description: current.description,
-              icon: current.icon,
-              position: current.position,
-              isFavorite: parseDocumentFavorite(current.isFavorite),
-              hideFromSearch: parseDocumentHideFromSearch(
-                current.hideFromSearch,
+      let contentCasConflict = false;
+      await db.transaction(async (tx) => {
+        if (useContentCas) {
+          const applied = await tx
+            .update(schema.documents)
+            .set(updates)
+            .where(
+              and(
+                eq(schema.documents.id, id),
+                eq(schema.documents.updatedAt, args.baseUpdatedAt as string),
               ),
-              visibility: current.visibility,
-              accessRole: access.role,
-              canEdit: true,
-              canManage: canManageRole(access.role),
-              createdAt: current.createdAt,
-              updatedAt: current.updatedAt,
-              source: serializeDocumentSource(current),
-              softDeletedDatabaseIds: [],
-            },
-          };
+            )
+            .returning({ id: schema.documents.id });
+          if (!applied || applied.length === 0) {
+            contentCasConflict = true;
+            return;
+          }
+        } else if (documentFieldsChanged) {
+          await tx
+            .update(schema.documents)
+            .set(updates)
+            .where(eq(schema.documents.id, id));
+        }
+
+        if (favoriteChanged) {
+          await setFavoriteMembership({
+            db: tx,
+            userEmail: requestUserEmail as string,
+            documentId: id,
+            favorite: args.isFavorite as boolean,
+            now: updates.updatedAt as string,
+          });
         }
-      } else {
-        await db
-          .update(schema.documents)
-          .set(updates)
-          .where(eq(schema.documents.id, id));
-      }
 
-      if (titleChanged && args.title !== undefined) {
-        await db
-          .update(schema.contentDatabases)
-          .set({ title: args.title, updatedAt: updates.updatedAt as string })
-          .where(eq(schema.contentDatabases.documentId, id));
+        if (titleChanged && args.title !== undefined) {
+          const [database] = await tx
+            .select({
+              id: schema.contentDatabases.id,
+              spaceId: schema.contentDatabases.spaceId,
+              systemRole: schema.contentDatabases.systemRole,
+            })
+            .from(schema.contentDatabases)
+            .where(eq(schema.contentDatabases.documentId, id));
+          if (database) {
+            const title =
+              database.systemRole === "files"
+                ? args.title.trim() || "Untitled"
+                : args.title;
+            await tx
+              .update(schema.contentDatabases)
+              .set({ title, updatedAt: updates.updatedAt as string })
+              .where(eq(schema.contentDatabases.id, database.id));
+            if (database.systemRole === "files" && database.spaceId) {
+              await tx
+                .update(schema.documents)
+                .set({ title, updatedAt: updates.updatedAt as string })
+                .where(eq(schema.documents.id, id));
+              await tx
+                .update(schema.contentSpaces)
+                .set({ name: title, updatedAt: updates.updatedAt as string })
+                .where(eq(schema.contentSpaces.id, database.spaceId));
+              const catalogReferences = await tx
+                .select({
+                  documentId: schema.contentSpaceCatalogItems.documentId,
+                })
+                .from(schema.contentSpaceCatalogItems)
+                .where(
+                  eq(schema.contentSpaceCatalogItems.spaceId, database.spaceId),
+                );
+              if (catalogReferences.length > 0) {
+                await tx
+                  .update(schema.documents)
+                  .set({ title, updatedAt: updates.updatedAt as string })
+                  .where(
+                    inArray(
+                      schema.documents.id,
+                      catalogReferences.map(
+                        (reference) => reference.documentId,
+                      ),
+                    ),
+                  );
+              }
+            }
+          }
+        }
+      });
+
+      if (contentCasConflict) {
+        // Someone else's write landed after the caller's snapshot. Don't
+        // apply this save at all (title/icon/favorite included — a partial
+        // apply would desync the fields from what the caller believes it
+        // just sent) and hand back the current server row instead so the
+        // caller can reconcile.
+        const [current] = await db
+          .select()
+          .from(schema.documents)
+          .where(eq(schema.documents.id, id));
+        return {
+          conflict: true,
+          id,
+          document: {
+            id: current.id,
+            urlPath: `/page/${current.id}`,
+            parentId: current.parentId,
+            title: current.title,
+            content: current.content,
+            description: current.description,
+            icon: current.icon,
+            position: current.position,
+            isFavorite: currentFavorite,
+            hideFromSearch: parseDocumentHideFromSearch(current.hideFromSearch),
+            visibility: current.visibility,
+            accessRole: access.role,
+            canEdit: canEditRole(access.role),
+            canManage: canManageRole(access.role),
+            createdAt: current.createdAt,
+            updatedAt: current.updatedAt,
+            source: serializeDocumentSource(current),
+            softDeletedDatabaseIds: [],
+          },
+        };
       }
 
       if (contentChanged) {
@@ -570,6 +659,9 @@ export default defineAction({
       .select()
       .from(schema.documents)
       .where(eq(schema.documents.id, id));
+    const finalFavorite = requestUserEmail
+      ? (await favoriteDocumentIds(db, requestUserEmail, [id])).has(id)
+      : parseDocumentFavorite(doc.isFavorite);
 
     await writeAppState("refresh-signal", { ts: Date.now() });
 
@@ -582,11 +674,11 @@ export default defineAction({
       description: doc.description,
       icon: doc.icon,
       position: doc.position,
-      isFavorite: parseDocumentFavorite(doc.isFavorite),
+      isFavorite: finalFavorite,
       hideFromSearch: parseDocumentHideFromSearch(doc.hideFromSearch),
       visibility: doc.visibility,
       accessRole: access.role,
-      canEdit: true,
+      canEdit: canEditRole(access.role),
       canManage: canManageRole(access.role),
       createdAt: doc.createdAt,
       updatedAt: doc.updatedAt,

package/corpus/templates/content/app/components/EmptyState.tsx

@@ -1,68 +1,15 @@
 import { useT } from "@agent-native/core/client/i18n";
-import type { Document } from "@shared/api";
 import { IconFileText, IconPlus } from "@tabler/icons-react";
-import { useQueryClient } from "@tanstack/react-query";
-import { useNavigate } from "react-router";
-import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
-import { useCreateDocument } from "@/hooks/use-documents";
-
-function nanoid(size = 12): string {
-  const chars =
-    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  const bytes = crypto.getRandomValues(new Uint8Array(size));
-  return Array.from(bytes, (b) => chars[b % chars.length]).join("");
-}
+import { useCreatePage } from "@/hooks/use-create-page";
 
 export function EmptyState() {
-  const navigate = useNavigate();
-  const queryClient = useQueryClient();
-  const createDocument = useCreateDocument();
+  const createPage = useCreatePage();
   const t = useT();
 
-  const handleCreate = async () => {
-    const id = nanoid();
-    const now = new Date().toISOString();
-    const tempDoc: Document = {
-      id,
-      parentId: null,
-      title: "",
-      content: "",
-      icon: null,
-      position: 9999,
-      isFavorite: false,
-      hideFromSearch: false,
-      visibility: "private",
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    // Optimistically inject into cache and navigate immediately
-    queryClient.setQueryData(
-      ["action", "list-documents", undefined],
-      (old: any) => {
-        const docs: Document[] =
-          old?.documents ?? (Array.isArray(old) ? old : []);
-        return { documents: [...docs, tempDoc] };
-      },
-    );
-    queryClient.setQueryData(["action", "get-document", { id }], tempDoc);
-    navigate(`/page/${id}`, { flushSync: true });
-
-    try {
-      await createDocument.mutateAsync({ id, title: "" });
-    } catch (err) {
-      queryClient.invalidateQueries({ queryKey: ["action", "list-documents"] });
-      queryClient.removeQueries({
-        queryKey: ["action", "get-document", { id }],
-      });
-      navigate("/");
-      toast.error(t("empty.createFailed"), {
-        description:
-          err instanceof Error ? err.message : t("empty.genericError"),
-      });
-    }
+  const handleCreate = () => {
+    void createPage().catch(() => undefined);
   };
 
   return (

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

@@ -188,6 +188,7 @@ interface CommentsSidebarProps {
   onSelectedThreadChange?: (id: string | null) => void;
   onHoveredThreadChange?: (id: string | null) => void;
   currentUserEmail?: string;
+  forceVisible?: boolean;
 }
 
 export function CommentsSidebar({
@@ -202,6 +203,7 @@ export function CommentsSidebar({
   onSelectedThreadChange,
   onHoveredThreadChange,
   currentUserEmail,
+  forceVisible = false,
 }: CommentsSidebarProps) {
   const t = useT();
   const { data: members = [] } = useMentionMembers();
@@ -433,7 +435,7 @@ export function CommentsSidebar({
 
   const hasContent =
     openThreads.length > 0 || !!pendingComment || resolvedThreads.length > 0;
-  if (!hasContent && !isLoading) return null;
+  if (!hasContent && !isLoading && !forceVisible) return null;
 
   // Sort open threads by their position in the document.
   const sortedThreads = [...openThreads].sort((a, b) => {
@@ -488,6 +490,11 @@ export function CommentsSidebar({
       className="relative w-80 shrink-0 pb-16"
       data-comments-sidebar
     >
+      {!hasContent && !isLoading ? (
+        <div className="px-4 py-8 text-sm text-muted-foreground">
+          {t("comments.empty")}
+        </div>
+      ) : null}
       {/* Pending new comment — positioned at the selection Y offset */}
       {pendingComment && (
         <div