@agent-native/core 0.102.2 → 0.103.0

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

@@ -0,0 +1,221 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import type { ContentDatabaseSourceTruthPolicy } from "../shared/api.js";
+import {
+  normalizeContentSpaceEmail,
+  resolveContentSpaceAccess,
+} from "./_content-space-access.js";
+import {
+  personalContentSpaceId,
+  provisionContentSpaces,
+  provisionSourceBackedContentSpace,
+} from "./_content-spaces.js";
+import {
+  LOCAL_FOLDER_SOURCE_TYPE,
+  localFolderSourceCapabilities,
+  localFolderSourceId,
+  localFolderSourceMetadata,
+} from "./_local-folder-source.js";
+
+const truthPolicySchema = z
+  .enum(["database_primary", "source_primary", "reviewed_bidirectional"])
+  .default("database_primary");
+
+export default defineAction({
+  description:
+    "Connect an opaque trusted local-folder handle to a canonical Files database. The browser or Desktop bridge keeps the real handle/path; Content stores only safe connection metadata.",
+  schema: z.object({
+    connectionId: z
+      .string()
+      .min(1)
+      .max(300)
+      .describe("Stable opaque ID from the trusted browser/Desktop registry"),
+    label: z.string().min(1).max(200).describe("User-visible folder label"),
+    spaceId: z
+      .string()
+      .optional()
+      .describe(
+        "Existing Content space whose Files database receives the source",
+      ),
+    databaseId: z
+      .string()
+      .optional()
+      .describe("Existing canonical Files database receiving the source"),
+    createSourceBackedSpace: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe("Create a separate private Content space for this folder"),
+    truthPolicy: truthPolicySchema.describe(
+      "Whether Content, the folder, or reviewed conflict resolution is authoritative",
+    ),
+    dryRun: z.boolean().optional().default(false),
+  }),
+  run: async (args) => {
+    const userEmail = getRequestUserEmail();
+    if (!userEmail) throw new Error("no authenticated user");
+    if (args.spaceId && args.databaseId) {
+      throw new Error("Choose either spaceId or databaseId, not both");
+    }
+    if (args.createSourceBackedSpace && (args.spaceId || args.databaseId)) {
+      throw new Error(
+        "A new source-backed space cannot also target an existing space or database",
+      );
+    }
+
+    const db = getDb();
+    const connectionId = args.connectionId.trim();
+    const label = args.label.trim();
+    const truthPolicy = args.truthPolicy as ContentDatabaseSourceTruthPolicy;
+    if (args.dryRun) {
+      const [existing] = await db
+        .select({
+          source: schema.contentDatabaseSources,
+          database: schema.contentDatabases,
+        })
+        .from(schema.contentDatabaseSources)
+        .innerJoin(
+          schema.contentDatabases,
+          eq(
+            schema.contentDatabases.id,
+            schema.contentDatabaseSources.databaseId,
+          ),
+        )
+        .where(
+          and(
+            eq(
+              schema.contentDatabaseSources.sourceType,
+              LOCAL_FOLDER_SOURCE_TYPE,
+            ),
+            eq(schema.contentDatabaseSources.sourceTable, connectionId),
+            eq(
+              schema.contentDatabaseSources.ownerEmail,
+              normalizeContentSpaceEmail(userEmail),
+            ),
+          ),
+        );
+      if (!existing?.database.spaceId) {
+        return {
+          connected: false as const,
+          sourceId: null,
+          connectionId,
+          label,
+          truthPolicy,
+          spaceId: null,
+          filesDatabaseId: null,
+        };
+      }
+      await resolveContentSpaceAccess(existing.database.spaceId, "editor");
+      return {
+        connected: true as const,
+        sourceId: existing.source.id,
+        sourceType: LOCAL_FOLDER_SOURCE_TYPE,
+        connectionId,
+        label,
+        truthPolicy,
+        spaceId: existing.database.spaceId,
+        filesDatabaseId: existing.database.id,
+      };
+    }
+    await provisionContentSpaces(db, userEmail);
+
+    let targetSpaceId = args.spaceId;
+    let targetDatabaseId = args.databaseId;
+    if (args.createSourceBackedSpace) {
+      const provisioned = await provisionSourceBackedContentSpace(
+        db,
+        userEmail,
+        { connectionId, name: label },
+      );
+      targetSpaceId = provisioned.spaceId;
+      targetDatabaseId = provisioned.filesDatabaseId;
+    } else if (!targetSpaceId && !targetDatabaseId) {
+      targetSpaceId = personalContentSpaceId(userEmail);
+    }
+
+    let database: typeof schema.contentDatabases.$inferSelect | undefined;
+    if (targetDatabaseId) {
+      [database] = await db
+        .select()
+        .from(schema.contentDatabases)
+        .where(eq(schema.contentDatabases.id, targetDatabaseId));
+      if (!database || database.deletedAt || database.systemRole !== "files") {
+        throw new Error(
+          `Database "${targetDatabaseId}" is not a canonical Files database`,
+        );
+      }
+      if (!database.spaceId) {
+        throw new Error(`Database "${targetDatabaseId}" has no Content space`);
+      }
+      targetSpaceId = database.spaceId;
+    }
+    if (!targetSpaceId) throw new Error("Content space is required");
+
+    await resolveContentSpaceAccess(targetSpaceId, "editor");
+    if (!database) {
+      [database] = await db
+        .select()
+        .from(schema.contentDatabases)
+        .where(
+          and(
+            eq(schema.contentDatabases.spaceId, targetSpaceId),
+            eq(schema.contentDatabases.systemRole, "files"),
+          ),
+        );
+    }
+    if (!database || database.deletedAt) {
+      throw new Error(`Content space "${targetSpaceId}" has no Files database`);
+    }
+
+    const id = localFolderSourceId(database.id, connectionId);
+    const now = new Date().toISOString();
+    const values = {
+      id,
+      ownerEmail: database.ownerEmail,
+      orgId: database.orgId,
+      databaseId: database.id,
+      sourceType: LOCAL_FOLDER_SOURCE_TYPE,
+      sourceName: label,
+      sourceTable: connectionId,
+      syncState: "linked",
+      freshness: "unknown",
+      capabilitiesJson: JSON.stringify(localFolderSourceCapabilities()),
+      metadataJson: JSON.stringify(
+        localFolderSourceMetadata({ connectionId, label, truthPolicy }),
+      ),
+      lastError: null,
+      createdAt: now,
+      updatedAt: now,
+    };
+    await db
+      .insert(schema.contentDatabaseSources)
+      .values(values)
+      .onConflictDoNothing();
+    await db
+      .update(schema.contentDatabaseSources)
+      .set({
+        sourceName: label,
+        capabilitiesJson: values.capabilitiesJson,
+        metadataJson: values.metadataJson,
+        updatedAt: now,
+      })
+      .where(eq(schema.contentDatabaseSources.id, id));
+
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    return {
+      connected: true as const,
+      sourceId: id,
+      sourceType: LOCAL_FOLDER_SOURCE_TYPE,
+      connectionId,
+      label,
+      truthPolicy,
+      spaceId: targetSpaceId,
+      filesDatabaseId: database.id,
+    };
+  },
+});

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

@@ -14,6 +14,12 @@ import type {
   ContentDatabaseResponse,
   CreateDatabaseRequest,
 } from "../shared/api.js";
+import { ensureDocumentFilesMembership } from "./_content-files.js";
+import { resolveContentSpaceAccess } from "./_content-space-access.js";
+import {
+  organizationContentSpaceId,
+  provisionContentSpaces,
+} from "./_content-spaces.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
 import { documentsPositionScope, withPositionLock } from "./_position-utils.js";
 import { nanoid, seedDefaultBlocksField } from "./_property-utils.js";
@@ -23,6 +29,10 @@ const createContentDatabaseSchema = z.object({
     .string()
     .optional()
     .describe("Existing document to convert into a database page"),
+  spaceId: z
+    .string()
+    .optional()
+    .describe("Content space for a new top-level database"),
   parentId: z
     .string()
     .nullish()
@@ -73,13 +83,84 @@ export async function createContentDatabaseCore(
   args: CreateDatabaseRequest,
   options: { db?: any } = {},
 ): Promise<ContentDatabaseResponse> {
-  const databaseId = await createContentDatabaseRecord(args, options);
+  const db = options.db ?? getDb();
+  const resolvedSpaceId = await resolveContentDatabaseSpace(args, db);
+  let databaseId: string | null = null;
+  if (options.db) {
+    databaseId = await createContentDatabaseRecord(args, {
+      db,
+      spaceId: resolvedSpaceId,
+    });
+  } else {
+    await db.transaction(async (tx: any) => {
+      databaseId = await createContentDatabaseRecord(args, {
+        db: tx,
+        spaceId: resolvedSpaceId,
+      });
+    });
+  }
+  if (!databaseId) throw new Error("Content database was not created");
   return getContentDatabaseResponse(databaseId);
 }
 
+async function healLegacyDocumentSpace(db: any, resource: any) {
+  const provisioned = await provisionContentSpaces(db, resource.ownerEmail);
+  const spaceId = resource.orgId
+    ? organizationContentSpaceId(resource.orgId)
+    : provisioned.personalSpaceId;
+  const [space] = await db
+    .select({ id: schema.contentSpaces.id })
+    .from(schema.contentSpaces)
+    .where(eq(schema.contentSpaces.id, spaceId));
+  if (!space) {
+    throw new Error(`Unable to resolve a Content space for "${resource.id}"`);
+  }
+  const now = new Date().toISOString();
+  await db
+    .update(schema.documents)
+    .set({ spaceId, updatedAt: now })
+    .where(eq(schema.documents.id, resource.id));
+  await ensureDocumentFilesMembership(db, resource.id, now);
+  return spaceId;
+}
+
+export async function resolveContentDatabaseSpace(
+  args: CreateDatabaseRequest,
+  db: any,
+): Promise<string> {
+  if (args.documentId) {
+    const access = await assertAccess("document", args.documentId, "editor");
+    const spaceId =
+      (access.resource.spaceId as string | null) ??
+      (await healLegacyDocumentSpace(db, access.resource));
+    if (args.spaceId && args.spaceId !== spaceId) {
+      throw new Error(
+        "A converted database must keep its document Content space",
+      );
+    }
+    return spaceId;
+  }
+  if (args.parentId) {
+    const access = await assertAccess("document", args.parentId, "editor");
+    const spaceId =
+      (access.resource.spaceId as string | null) ??
+      (await healLegacyDocumentSpace(db, access.resource));
+    if (args.spaceId && args.spaceId !== spaceId) {
+      throw new Error("Nested databases must use their parent Content space");
+    }
+    return spaceId;
+  }
+  const userEmail = getRequestUserEmail();
+  if (!userEmail) throw new Error("no authenticated user");
+  const provisioned = await provisionContentSpaces(db, userEmail);
+  const spaceId = args.spaceId ?? provisioned.personalSpaceId;
+  await resolveContentSpaceAccess(spaceId, "editor");
+  return spaceId;
+}
+
 export async function createContentDatabaseRecord(
   args: CreateDatabaseRequest,
-  options: { db?: any } = {},
+  options: { db?: any; spaceId?: string } = {},
 ): Promise<string> {
   const db = options.db ?? getDb();
   const now = new Date().toISOString();
@@ -89,6 +170,7 @@ export async function createContentDatabaseRecord(
   let ownerEmail = getRequestUserEmail();
   if (!ownerEmail) throw new Error("no authenticated user");
   let orgId = getRequestOrgId() ?? null;
+  let spaceId = options.spaceId ?? null;
   let inheritedShares: Array<{
     principalType: "user" | "org";
     principalId: string;
@@ -100,13 +182,34 @@ export async function createContentDatabaseRecord(
     const document = access.resource;
     ownerEmail = document.ownerEmail as string;
     orgId = (document.orgId as string | null) ?? null;
+    spaceId = (document.spaceId as string | null) ?? spaceId;
+    if (!spaceId) {
+      throw new Error(`Document "${documentId}" has no Content space`);
+    }
+    if (args.spaceId && args.spaceId !== spaceId) {
+      throw new Error(
+        "A converted database must keep its document Content space",
+      );
+    }
     title = databaseTitleForPage(title, document.title);
 
     const [existing] = await db
       .select()
       .from(schema.contentDatabases)
       .where(eq(schema.contentDatabases.documentId, documentId));
-    if (existing) return existing.id;
+    if (existing) {
+      if (existing.spaceId !== spaceId) {
+        await db
+          .update(schema.contentDatabases)
+          .set({ spaceId, updatedAt: now })
+          .where(eq(schema.contentDatabases.id, existing.id));
+      }
+      await ensureDocumentFilesMembership(db, documentId, now, {
+        userEmail: getRequestUserEmail(),
+        orgId: orgId ?? undefined,
+      });
+      return existing.id;
+    }
 
     if (title && title !== document.title && !document.title.trim()) {
       await db
@@ -131,6 +234,13 @@ export async function createContentDatabaseRecord(
       const parent = parentAccess.resource;
       ownerEmail = parent.ownerEmail as string;
       orgId = (parent.orgId as string | null) ?? null;
+      spaceId = (parent.spaceId as string | null) ?? spaceId;
+      if (!spaceId) {
+        throw new Error(`Parent document "${parentId}" has no Content space`);
+      }
+      if (args.spaceId && args.spaceId !== spaceId) {
+        throw new Error("Nested databases must use their parent Content space");
+      }
       visibility = parent.visibility ?? "private";
       hideFromSearch = parent.hideFromSearch ?? 0;
       inheritedShares = await db
@@ -141,6 +251,16 @@ export async function createContentDatabaseRecord(
         })
         .from(schema.documentShares)
         .where(eq(schema.documentShares.resourceId, parentId));
+    } else {
+      if (!spaceId) {
+        throw new Error(
+          "A top-level database requires a resolved Content space",
+        );
+      }
+      const spaceAccess = await resolveContentSpaceAccess(spaceId, "editor");
+      ownerEmail = getRequestUserEmail() ?? ownerEmail;
+      orgId = spaceAccess.space.orgId;
+      visibility = orgId ? "org" : "private";
     }
 
     documentId = nanoid();
@@ -168,6 +288,7 @@ export async function createContentDatabaseRecord(
 
         await db.insert(schema.documents).values({
           id: documentId!,
+          spaceId,
           ownerEmail: resolvedOwnerEmail,
           orgId,
           parentId,
@@ -203,6 +324,7 @@ export async function createContentDatabaseRecord(
   const databaseId = nanoid();
   await db.insert(schema.contentDatabases).values({
     id: databaseId,
+    spaceId,
     ownerEmail,
     orgId,
     documentId,
@@ -214,6 +336,10 @@ export async function createContentDatabaseRecord(
   // Every database is seeded with one primary "Content" Blocks field, backed
   // by `documents.content`, so each row's body is a first-class property.
   await seedDefaultBlocksField({ databaseId, ownerEmail, orgId, now, db });
+  await ensureDocumentFilesMembership(db, documentId, now, {
+    userEmail: getRequestUserEmail(),
+    orgId: orgId ?? undefined,
+  });
 
   return databaseId;
 }

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

@@ -14,10 +14,9 @@ import {
   parseDocumentFavorite,
   parseDocumentHideFromSearch,
 } from "../server/lib/documents.js";
-import {
-  createLocalFileDocument,
-  isContentLocalFileMode,
-} from "./_local-file-documents.js";
+import { ensureDocumentFilesMembership } from "./_content-files.js";
+import { resolveContentSpaceAccess } from "./_content-space-access.js";
+import { provisionContentSpaces } from "./_content-spaces.js";
 import { documentsPositionScope, withPositionLock } from "./_position-utils.js";
 
 function nanoid(size = 12): string {
@@ -29,13 +28,6 @@ function nanoid(size = 12): string {
   return id;
 }
 
-function assertCanWriteAppState() {
-  if (getRequestUserEmail() || process.env.AGENT_USER_EMAIL) return;
-  throw new Error(
-    "Application state access requires an authenticated request context or AGENT_USER_EMAIL env var",
-  );
-}
-
 export default defineAction({
   description: "Create a new document.",
   schema: z.object({
@@ -43,6 +35,10 @@ export default defineAction({
       .string()
       .optional()
       .describe("Pre-generated document ID (for optimistic UI)"),
+    spaceId: z
+      .string()
+      .optional()
+      .describe("Content space for a new top-level document"),
     title: z.string().describe("Document title"),
     content: z.string().optional().describe("Markdown content"),
     description: z
@@ -66,21 +62,6 @@ export default defineAction({
     }),
   },
   run: async (args) => {
-    if (await isContentLocalFileMode()) {
-      assertCanWriteAppState();
-      const doc = await createLocalFileDocument(args);
-      await writeAppState("refresh-signal", { ts: Date.now() });
-      return {
-        ...doc,
-        urlPath: `/page/${doc.id}`,
-        deepLink: buildDeepLink({
-          app: "content",
-          view: "editor",
-          params: { documentId: doc.id },
-        }),
-      };
-    }
-
     const title = args.title;
 
     let content = args.content || "";
@@ -130,6 +111,28 @@ export default defineAction({
         .where(eq(schema.documentShares.resourceId, parentId));
     }
 
+    let spaceId: string;
+    if (parentId) {
+      const [parent] = await db
+        .select({ spaceId: schema.documents.spaceId })
+        .from(schema.documents)
+        .where(eq(schema.documents.id, parentId));
+      if (!parent?.spaceId) {
+        throw new Error(`Parent document "${parentId}" has no Content space`);
+      }
+      if (args.spaceId && args.spaceId !== parent.spaceId) {
+        throw new Error("Nested documents must use their parent Content space");
+      }
+      spaceId = parent.spaceId;
+    } else {
+      const provisioned = await provisionContentSpaces(db, currentUserEmail);
+      spaceId = args.spaceId ?? provisioned.personalSpaceId;
+      const spaceAccess = await resolveContentSpaceAccess(spaceId, "editor");
+      ownerEmail = currentUserEmail;
+      orgId = spaceAccess.space.orgId;
+      visibility = orgId ? "org" : "private";
+    }
+
     const now = new Date().toISOString();
     const id = args.id || nanoid();
 
@@ -154,39 +157,46 @@ export default defineAction({
 
         const position = (maxPos[0]?.max ?? -1) + 1;
 
-        await db.insert(schema.documents).values({
-          id,
-          ownerEmail,
-          orgId,
-          parentId,
-          title,
-          content,
-          description,
-          icon,
-          position,
-          isFavorite: 0,
-          hideFromSearch,
-          visibility,
-          createdAt: now,
-          updatedAt: now,
+        await db.transaction(async (tx) => {
+          await tx.insert(schema.documents).values({
+            id,
+            spaceId,
+            ownerEmail,
+            orgId,
+            parentId,
+            title,
+            content,
+            description,
+            icon,
+            position,
+            isFavorite: 0,
+            hideFromSearch,
+            visibility,
+            createdAt: now,
+            updatedAt: now,
+          });
+
+          if (inheritedShares.length > 0) {
+            await tx.insert(schema.documentShares).values(
+              inheritedShares.map((share) => ({
+                id: nanoid(),
+                resourceId: id,
+                principalType: share.principalType,
+                principalId: share.principalId,
+                role: share.role,
+                createdBy: currentUserEmail,
+                createdAt: now,
+              })),
+            );
+          }
+          await ensureDocumentFilesMembership(tx, id, now, {
+            userEmail: currentUserEmail,
+            orgId: orgId ?? undefined,
+          });
         });
       },
     );
 
-    if (inheritedShares.length > 0) {
-      await db.insert(schema.documentShares).values(
-        inheritedShares.map((share) => ({
-          id: nanoid(),
-          resourceId: id,
-          principalType: share.principalType,
-          principalId: share.principalId,
-          role: share.role,
-          createdBy: currentUserEmail,
-          createdAt: now,
-        })),
-      );
-    }
-
     const [doc] = await db
       .select()
       .from(schema.documents)

package/corpus/templates/content/actions/create-inline-content-database.ts

@@ -10,6 +10,7 @@ import { nanoid } from "./_property-utils.js";
 import {
   createContentDatabaseRecord,
   databaseTitleForPage,
+  resolveContentDatabaseSpace,
 } from "./create-content-database.js";
 
 function createInlineDatabaseBlockId(): string {
@@ -33,6 +34,10 @@ export default defineAction({
     const ownerBlockId = createInlineDatabaseBlockId();
     let databaseId: string | null = null;
     let databaseDocumentId: string | null = null;
+    const spaceId = await resolveContentDatabaseSpace(
+      { parentId: hostDocumentId },
+      db,
+    );
 
     await db.transaction(async (tx) => {
       databaseId = await createContentDatabaseRecord(
@@ -41,7 +46,7 @@ export default defineAction({
           title: databaseTitleForPage(title),
           description,
         },
-        { db: tx },
+        { db: tx, spaceId },
       );
 
       const [updated] = await tx

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

@@ -14,6 +14,9 @@ export default defineAction({
   }),
   run: async ({ databaseId }) => {
     const { database } = await assertContentDatabaseLifecycleAccess(databaseId);
+    if (database.systemRole) {
+      throw new Error("System Content databases cannot be deleted");
+    }
     const db = getDb();
     const deletedAt = database.deletedAt ?? new Date().toISOString();
 

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

@@ -6,11 +6,6 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { chunks } from "./_batch-utils.js";
-import {
-  deleteLocalFileDocument,
-  isLocalDocumentId,
-  isContentLocalFileMode,
-} from "./_local-file-documents.js";
 
 const DELETE_BATCH_SIZE = 90;
 
@@ -365,16 +360,17 @@ export default defineAction({
     const id = args.id;
     if (!id) throw new Error("--id is required");
 
-    if ((await isContentLocalFileMode()) && isLocalDocumentId(id)) {
-      const result = await deleteLocalFileDocument(id);
-      await writeAppState("refresh-signal", { ts: Date.now() });
-      return result;
-    }
-
     const access = await assertAccess("document", id, "admin");
     const existing = access.resource;
 
     const db = getDb();
+    const [systemDatabase] = await db
+      .select({ systemRole: schema.contentDatabases.systemRole })
+      .from(schema.contentDatabases)
+      .where(eq(schema.contentDatabases.documentId, id));
+    if (systemDatabase?.systemRole) {
+      throw new Error("System Content database documents cannot be deleted");
+    }
     const deleted = await deleteDocumentRecursive(
       db,
       id,