@agent-native/core 0.102.2 → 0.103.1

package/corpus/templates/content/actions/_database-source-utils.ts

@@ -81,6 +81,11 @@ import {
   type ExistingBuilderSourceRowIdentity,
 } from "./_builder-cms-source-adapter.js";
 import { mergeBuilderCmsWriteSettingsIntoJson } from "./_builder-cms-write-settings.js";
+import { ensureDocumentsFilesMembership } from "./_content-files.js";
+import {
+  organizationContentSpaceId,
+  provisionContentSpaces,
+} from "./_content-spaces.js";
 import {
   databaseItemsPositionScope,
   documentsPositionScope,
@@ -142,6 +147,9 @@ type SourceMetadataRecord = {
   allowPublicationTransitions?: boolean;
   notes?: string | null;
   readMode?: string | null;
+  connectionId?: string | null;
+  connectionLabel?: string | null;
+  truthPolicy?: ContentDatabaseSource["metadata"]["truthPolicy"];
   liveReadConfigured?: boolean;
   lastReadEntryCount?: number;
   lastReadMatchedRowCount?: number;
@@ -213,7 +221,8 @@ function normalizeSourceType(
   if (
     value === "builder-cms" ||
     value === "local-table" ||
-    value === "notion-database"
+    value === "notion-database" ||
+    value === "local-folder"
   )
     return value;
   return "mock-local";
@@ -230,12 +239,9 @@ function normalizeChangeKind(
 }
 
 function normalizeChangeDirection(
-  _value: string | null | undefined,
+  value: string | null | undefined,
 ): ContentDatabaseSourceChangeDirection {
-  // Integrations are the source of truth; change-sets only flow outbound
-  // (local → provider). Any legacy "incoming" rows coerce to outbound and are
-  // pruned by the resync cleanup.
-  return "outbound";
+  return value === "incoming" ? "incoming" : "outbound";
 }
 
 function normalizePushMode(
@@ -296,6 +302,9 @@ function normalizeCapabilities(
     canStageLocalRevision: parsed?.canStageLocalRevision === true,
     liveWritesEnabled: parsed?.liveWritesEnabled === true,
     readOnlyRefresh: parsed?.readOnlyRefresh !== false,
+    canRename: parsed?.canRename === true,
+    canReveal: parsed?.canReveal === true,
+    canUseLocalComponents: parsed?.canUseLocalComponents === true,
   };
 }
 
@@ -306,6 +315,7 @@ function sourceMetadataLabel(
   if (sourceType === "builder-cms") return `builder.cms.${sourceTable}`;
   if (sourceType === "local-table") return `local.table.${sourceTable}`;
   if (sourceType === "notion-database") return `notion.database.${sourceTable}`;
+  if (sourceType === "local-folder") return `local.folder.${sourceTable}`;
   return `mock-local.${sourceTable}`;
 }
 
@@ -3710,6 +3720,14 @@ async function loadSourceSnapshot(
         metadata.allowPublicationTransitions === true,
       notes: metadata.notes ?? null,
       readMode: metadata.readMode ?? null,
+      connectionId: metadata.connectionId ?? null,
+      connectionLabel: metadata.connectionLabel ?? null,
+      truthPolicy:
+        metadata.truthPolicy === "database_primary" ||
+        metadata.truthPolicy === "source_primary" ||
+        metadata.truthPolicy === "reviewed_bidirectional"
+          ? metadata.truthPolicy
+          : undefined,
       liveReadConfigured: metadata.liveReadConfigured === true,
       lastReadEntryCount:
         typeof metadata.lastReadEntryCount === "number"
@@ -5105,6 +5123,7 @@ export async function importBuilderCmsEntriesAsDatabaseItems(args: {
     .select()
     .from(schema.documents)
     .where(eq(schema.documents.id, args.database.documentId));
+  if (!databaseDocument) throw new Error("Database page not found.");
   const currentItems = await db
     .select({
       item: schema.contentDatabaseItems,
@@ -5116,6 +5135,63 @@ export async function importBuilderCmsEntriesAsDatabaseItems(args: {
       eq(schema.documents.id, schema.contentDatabaseItems.documentId),
     )
     .where(eq(schema.contentDatabaseItems.databaseId, args.database.id));
+  let resolvedDatabaseSpaceId =
+    args.database.spaceId ?? databaseDocument.spaceId;
+  if (
+    args.database.spaceId &&
+    databaseDocument.spaceId &&
+    args.database.spaceId !== databaseDocument.spaceId
+  ) {
+    throw new Error(
+      "Database page and database belong to different Content spaces.",
+    );
+  }
+  if (!resolvedDatabaseSpaceId) {
+    const provisioned = await provisionContentSpaces(
+      db,
+      args.database.ownerEmail,
+    );
+    const legacyOrgId = args.database.orgId ?? databaseDocument.orgId;
+    resolvedDatabaseSpaceId = legacyOrgId
+      ? organizationContentSpaceId(legacyOrgId)
+      : provisioned.personalSpaceId;
+  }
+  const databaseSpaceId = resolvedDatabaseSpaceId;
+  if (
+    currentItems.some(
+      (row) => row.document.spaceId && row.document.spaceId !== databaseSpaceId,
+    )
+  ) {
+    throw new Error("Database contains a row from a different Content space.");
+  }
+  const legacyDocumentIds = [
+    databaseDocument.id,
+    ...currentItems
+      .filter((row) => !row.document.spaceId)
+      .map((row) => row.document.id),
+  ];
+  if (
+    args.database.spaceId !== databaseSpaceId ||
+    databaseDocument.spaceId !== databaseSpaceId ||
+    legacyDocumentIds.length > 1
+  ) {
+    await db.transaction(async (tx) => {
+      await tx
+        .update(schema.contentDatabases)
+        .set({ spaceId: databaseSpaceId, updatedAt: args.now })
+        .where(eq(schema.contentDatabases.id, args.database.id));
+      await tx
+        .update(schema.documents)
+        .set({ spaceId: databaseSpaceId, updatedAt: args.now })
+        .where(inArray(schema.documents.id, legacyDocumentIds));
+      await ensureDocumentsFilesMembership(
+        tx,
+        legacyDocumentIds,
+        args.now,
+        args.database.ownerEmail,
+      );
+    });
+  }
   const representedDocumentIds = new Set(
     (args.existingSourceRows ?? [])
       .map((row) => row.documentId)
@@ -5196,6 +5272,7 @@ export async function importBuilderCmsEntriesAsDatabaseItems(args: {
             );
             documentRows.push({
               id: documentId,
+              spaceId: databaseSpaceId,
               ownerEmail: args.database.ownerEmail,
               orgId: args.database.orgId,
               parentId: args.database.documentId,
@@ -5226,7 +5303,7 @@ export async function importBuilderCmsEntriesAsDatabaseItems(args: {
           await db.transaction(async (tx) => {
             for (const chunk of chunks(
               documentRows,
-              bulkChunkSizeForColumnCount(13),
+              bulkChunkSizeForColumnCount(14),
             )) {
               await tx
                 .insert(schema.documents)
@@ -5242,6 +5319,12 @@ export async function importBuilderCmsEntriesAsDatabaseItems(args: {
                 .values(chunk)
                 .onConflictDoNothing();
             }
+            await ensureDocumentsFilesMembership(
+              tx,
+              documentRows.map((row) => row.id),
+              args.now,
+              args.database.ownerEmail,
+            );
           });
 
           return { imported: itemRows.length, importedEntriesByDocumentId };

package/corpus/templates/content/actions/_database-utils.ts

@@ -43,6 +43,7 @@ type DocumentListRow = Omit<typeof schema.documents.$inferSelect, "content">;
 // string below; opened documents use their dedicated document read path instead.
 export const contentDatabaseListDocumentSelection = {
   id: schema.documents.id,
+  spaceId: schema.documents.spaceId,
   parentId: schema.documents.parentId,
   title: schema.documents.title,
   description: schema.documents.description,
@@ -462,7 +463,12 @@ export async function getDatabaseItemByDocumentId(
         schema.contentDatabaseItems.id,
       ),
     )
-    .where(and(...clauses));
+    .where(and(...clauses))
+    .orderBy(
+      sql`CASE WHEN ${schema.contentDatabaseSourceRows.sourceId} IS NOT NULL THEN 0 ELSE 1 END`,
+      sql`CASE WHEN ${schema.contentDatabases.systemRole} IS NULL THEN 0 ELSE 1 END`,
+      asc(schema.contentDatabases.id),
+    );
   return row ?? null;
 }
 

package/corpus/templates/content/actions/_local-file-documents.ts

@@ -4,7 +4,6 @@ import {
   deleteLocalArtifactFile,
   ensureLocalArtifactRoot,
   getLocalArtifactApp,
-  isAgentNativeLocalFileMode,
   loadAgentNativeManifest,
   listLocalArtifactFiles,
   readLocalArtifactFile,
@@ -57,13 +56,6 @@ function localOptions(): LocalArtifactOptions {
   };
 }
 
-export async function isContentLocalFileMode() {
-  return isAgentNativeLocalFileMode({
-    appId: CONTENT_APP_ID,
-    defaults: CONTENT_LOCAL_DEFAULTS,
-  });
-}
-
 function encodeIdPath(filePath: string): string {
   return Buffer.from(filePath, "utf8").toString("base64url");
 }
@@ -242,7 +234,6 @@ function localFileDocumentsCacheScope() {
   return JSON.stringify({
     manifest: process.env.AGENT_NATIVE_MANIFEST,
     manifestPath: process.env.AGENT_NATIVE_MANIFEST_PATH,
-    mode: process.env.AGENT_NATIVE_MODE,
     dataMode: process.env.AGENT_NATIVE_DATA_MODE,
   });
 }

package/corpus/templates/content/actions/_local-folder-source.ts

@@ -0,0 +1,53 @@
+import { createHash } from "node:crypto";
+
+import type {
+  ContentDatabaseSourceCapabilities,
+  ContentDatabaseSourceTruthPolicy,
+} from "../shared/api.js";
+
+export const LOCAL_FOLDER_SOURCE_TYPE = "local-folder" as const;
+
+export function localFolderSourceId(databaseId: string, connectionId: string) {
+  return `content_database_source_local_folder_${createHash("sha256")
+    .update(`${databaseId}:${connectionId}`)
+    .digest("hex")
+    .slice(0, 32)}`;
+}
+
+export function localFolderSourceCapabilities(): ContentDatabaseSourceCapabilities {
+  return {
+    canRefresh: true,
+    canCreateChangeSets: true,
+    canWriteFields: true,
+    canWriteBody: true,
+    canPush: true,
+    canPull: true,
+    canPublish: false,
+    canDelete: true,
+    canStageLocalRevision: true,
+    liveWritesEnabled: false,
+    readOnlyRefresh: false,
+    canRename: true,
+    canReveal: true,
+    canUseLocalComponents: true,
+  };
+}
+
+export function localFolderSourceMetadata(input: {
+  connectionId: string;
+  label: string;
+  truthPolicy: ContentDatabaseSourceTruthPolicy;
+}) {
+  return {
+    primaryKey: "relative_path",
+    naturalKeyField: "relative_path",
+    titleField: "title",
+    readMode: "trusted-local-bridge",
+    connectionId: input.connectionId,
+    connectionLabel: input.label,
+    truthPolicy: input.truthPolicy,
+    writeMode: "stage_only" as const,
+    notes:
+      "The trusted local bridge owns the folder handle or path; SQL stores only this opaque connection identity.",
+  };
+}

package/corpus/templates/content/actions/_property-utils.ts

@@ -184,8 +184,10 @@ export function serializeDatabaseViewConfig(
   return JSON.stringify(normalizeDatabaseViewConfig(value));
 }
 
-function defaultDatabaseViewConfig(): ContentDatabaseViewConfig {
-  const view = defaultDatabaseView();
+export function defaultDatabaseViewConfig(
+  type: ContentDatabaseView["type"] = "table",
+): ContentDatabaseViewConfig {
+  const view = defaultDatabaseView({}, type);
   return {
     activeViewId: view.id,
     views: [view],
@@ -258,7 +260,9 @@ function defaultDatabaseView(
                 ? "Timeline"
                 : type === "form"
                   ? "Form"
-                  : "Table",
+                  : type === "sidebar"
+                    ? "Sidebar"
+                    : "Table",
     type,
     sorts: values.sorts ?? [],
     filters: values.filters ?? [],
@@ -289,7 +293,8 @@ function normalizeDatabaseView(value: unknown): ContentDatabaseView | null {
     view.type === "gallery" ||
     view.type === "calendar" ||
     view.type === "timeline" ||
-    view.type === "form"
+    view.type === "form" ||
+    view.type === "sidebar"
       ? view.type
       : "table";
   return {

package/corpus/templates/content/actions/add-database-item.ts

@@ -10,6 +10,7 @@ import {
   isComputedPropertyType,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { ensureDocumentFilesMembership } from "./_content-files.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
 import {
   databaseItemsPositionScope,
@@ -47,60 +48,42 @@ export default defineAction({
       "editor",
     );
     const databaseDocument = access.resource;
+    if (
+      database.spaceId &&
+      databaseDocument.spaceId &&
+      databaseDocument.spaceId !== database.spaceId
+    ) {
+      throw new Error(
+        `Database "${databaseId}" has inconsistent Content space`,
+      );
+    }
     const now = new Date().toISOString();
+    const databaseSpaceId =
+      database.spaceId ?? (databaseDocument.spaceId as string | null);
+    if (!databaseSpaceId) {
+      throw new Error("Database does not belong to a Content space.");
+    }
+    if (databaseSpaceId && (!database.spaceId || !databaseDocument.spaceId)) {
+      await db.transaction(async (tx) => {
+        if (!database.spaceId) {
+          await tx
+            .update(schema.contentDatabases)
+            .set({ spaceId: databaseSpaceId, updatedAt: now })
+            .where(eq(schema.contentDatabases.id, databaseId));
+        }
+        if (!databaseDocument.spaceId) {
+          await tx
+            .update(schema.documents)
+            .set({ spaceId: databaseSpaceId, updatedAt: now })
+            .where(eq(schema.documents.id, database.documentId));
+        }
+        await ensureDocumentFilesMembership(tx, database.documentId, now);
+      });
+    }
 
     const documentId = nanoid();
     const itemId = nanoid();
 
-    await withPositionLock(
-      documentsPositionScope(database.ownerEmail, database.documentId),
-      async () => {
-        const [maxDocPos] = await db
-          .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
-          .from(schema.documents)
-          .where(
-            and(
-              eq(schema.documents.ownerEmail, database.ownerEmail),
-              eq(schema.documents.parentId, database.documentId),
-            ),
-          );
-
-        await db.insert(schema.documents).values({
-          id: documentId,
-          ownerEmail: database.ownerEmail,
-          orgId: database.orgId,
-          parentId: database.documentId,
-          title: title?.trim() ?? "",
-          content: "",
-          icon: null,
-          position: (maxDocPos?.max ?? -1) + 1,
-          isFavorite: 0,
-          hideFromSearch: databaseDocument.hideFromSearch ?? 0,
-          visibility: databaseDocument.visibility ?? "private",
-          createdAt: now,
-          updatedAt: now,
-        });
-      },
-    );
-
-    await withPositionLock(databaseItemsPositionScope(databaseId), async () => {
-      const [maxItemPos] = await db
-        .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
-        .from(schema.contentDatabaseItems)
-        .where(eq(schema.contentDatabaseItems.databaseId, databaseId));
-
-      await db.insert(schema.contentDatabaseItems).values({
-        id: itemId,
-        ownerEmail: database.ownerEmail,
-        orgId: database.orgId,
-        databaseId,
-        documentId,
-        position: (maxItemPos?.max ?? -1) + 1,
-        createdAt: now,
-        updatedAt: now,
-      });
-    });
-
     const inheritedShares = await db
       .select({
         principalType: schema.documentShares.principalType,
@@ -110,21 +93,10 @@ export default defineAction({
       .from(schema.documentShares)
       .where(eq(schema.documentShares.resourceId, database.documentId));
 
-    if (inheritedShares.length > 0) {
-      await db.insert(schema.documentShares).values(
-        inheritedShares.map((share) => ({
-          id: nanoid(),
-          resourceId: documentId,
-          principalType: share.principalType,
-          principalId: share.principalId,
-          role: share.role,
-          createdBy: getRequestUserEmail() ?? database.ownerEmail,
-          createdAt: now,
-        })),
-      );
-    }
-
     const initialValues = Object.entries(propertyValues ?? {});
+    const propertyValueRows: Array<
+      typeof schema.documentPropertyValues.$inferInsert
+    > = [];
     if (initialValues.length > 0) {
       const requestedPropertyIds = initialValues.map(
         ([propertyId]) => propertyId,
@@ -153,7 +125,7 @@ export default defineAction({
         const definition = definitionById.get(propertyId);
         const type = definition?.type as DocumentPropertyType | undefined;
         if (!definition || !type || isComputedPropertyType(type)) continue;
-        await db.insert(schema.documentPropertyValues).values({
+        propertyValueRows.push({
           id: nanoid(),
           ownerEmail: database.ownerEmail,
           documentId,
@@ -165,7 +137,78 @@ export default defineAction({
       }
     }
 
-    await writeAppState("refresh-signal", { ts: Date.now() });
+    await withPositionLock(
+      documentsPositionScope(database.ownerEmail, database.documentId),
+      () =>
+        withPositionLock(databaseItemsPositionScope(databaseId), async () => {
+          await db.transaction(async (tx) => {
+            const [maxDocPos] = await tx
+              .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+              .from(schema.documents)
+              .where(
+                and(
+                  eq(schema.documents.ownerEmail, database.ownerEmail),
+                  eq(schema.documents.parentId, database.documentId),
+                ),
+              );
+            const [maxItemPos] = await tx
+              .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+              .from(schema.contentDatabaseItems)
+              .where(eq(schema.contentDatabaseItems.databaseId, databaseId));
+
+            await tx.insert(schema.documents).values({
+              id: documentId,
+              spaceId: databaseSpaceId,
+              ownerEmail: database.ownerEmail,
+              orgId: database.orgId,
+              parentId: database.documentId,
+              title: title?.trim() ?? "",
+              content: "",
+              icon: null,
+              position: (maxDocPos?.max ?? -1) + 1,
+              isFavorite: 0,
+              hideFromSearch: databaseDocument.hideFromSearch ?? 0,
+              visibility: databaseDocument.visibility ?? "private",
+              createdAt: now,
+              updatedAt: now,
+            });
+            await tx.insert(schema.contentDatabaseItems).values({
+              id: itemId,
+              ownerEmail: database.ownerEmail,
+              orgId: database.orgId,
+              databaseId,
+              documentId,
+              position: (maxItemPos?.max ?? -1) + 1,
+              createdAt: now,
+              updatedAt: now,
+            });
+            if (inheritedShares.length > 0) {
+              await tx.insert(schema.documentShares).values(
+                inheritedShares.map((share) => ({
+                  id: nanoid(),
+                  resourceId: documentId,
+                  principalType: share.principalType,
+                  principalId: share.principalId,
+                  role: share.role,
+                  createdBy: getRequestUserEmail() ?? database.ownerEmail,
+                  createdAt: now,
+                })),
+              );
+            }
+            if (propertyValueRows.length > 0) {
+              await tx
+                .insert(schema.documentPropertyValues)
+                .values(propertyValueRows);
+            }
+            await ensureDocumentFilesMembership(tx, documentId, now);
+          });
+        }),
+    );
+
+    await writeAppState("refresh-signal", { ts: Date.now() }).catch(() => {
+      // The row is already committed; polling will reconcile if a concurrent
+      // SQLite writer briefly blocks this best-effort refresh hint.
+    });
 
     return {
       ...(await getContentDatabaseResponse(databaseId)),

package/corpus/templates/content/actions/backfill-content-files.ts

@@ -0,0 +1,22 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { reconcileContentFilesMemberships } from "./_content-files.js";
+import { provisionContentSpaces } from "./_content-spaces.js";
+
+export default defineAction({
+  description:
+    "Assign legacy pages to Content spaces and reconcile their canonical Files database memberships.",
+  schema: z.object({}),
+  run: async () => {
+    const userEmail = getRequestUserEmail();
+    if (!userEmail) throw new Error("no authenticated user");
+    await provisionContentSpaces(getDb(), userEmail);
+    const result = await reconcileContentFilesMemberships(getDb(), userEmail);
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    return result;
+  },
+});