@agent-native/core 0.102.2 → 0.103.0

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

@@ -0,0 +1,175 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { and, eq, inArray, ne } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { resolveContentSpaceAccess } from "./_content-space-access.js";
+import { LOCAL_FOLDER_SOURCE_TYPE } from "./_local-folder-source.js";
+
+export default defineAction({
+  description:
+    "Disconnect a local-folder source without deleting its local files or the SQL-backed Content pages it materialized.",
+  schema: z.object({ sourceId: z.string().min(1) }),
+  run: async ({ sourceId }) => {
+    const db = getDb();
+    const [target] = await db
+      .select({
+        source: schema.contentDatabaseSources,
+        database: schema.contentDatabases,
+      })
+      .from(schema.contentDatabaseSources)
+      .innerJoin(
+        schema.contentDatabases,
+        eq(
+          schema.contentDatabases.id,
+          schema.contentDatabaseSources.databaseId,
+        ),
+      )
+      .where(eq(schema.contentDatabaseSources.id, sourceId));
+    if (
+      !target ||
+      target.source.sourceType !== LOCAL_FOLDER_SOURCE_TYPE ||
+      !target.database.spaceId
+    ) {
+      throw new Error(`Local folder source "${sourceId}" not found`);
+    }
+    await resolveContentSpaceAccess(target.database.spaceId, "editor");
+    const spaceId = target.database.spaceId;
+    let disconnectedDocuments = 0;
+    const now = new Date().toISOString();
+
+    await db.transaction(async (tx: any) => {
+      const rows = await tx
+        .select({ documentId: schema.contentDatabaseSourceRows.documentId })
+        .from(schema.contentDatabaseSourceRows)
+        .where(eq(schema.contentDatabaseSourceRows.sourceId, sourceId));
+      const documentIds: string[] = [
+        ...new Set<string>(rows.map((row: any) => String(row.documentId))),
+      ];
+      disconnectedDocuments = documentIds.length;
+      await tx
+        .delete(schema.contentDatabaseSourceExecutions)
+        .where(eq(schema.contentDatabaseSourceExecutions.sourceId, sourceId));
+      await tx
+        .delete(schema.contentDatabaseSourceExecutionClaims)
+        .where(
+          eq(schema.contentDatabaseSourceExecutionClaims.sourceId, sourceId),
+        );
+      await tx
+        .delete(schema.contentDatabaseSourceChangeReviews)
+        .where(
+          eq(schema.contentDatabaseSourceChangeReviews.sourceId, sourceId),
+        );
+      await tx
+        .delete(schema.contentDatabaseSourceChangeSets)
+        .where(eq(schema.contentDatabaseSourceChangeSets.sourceId, sourceId));
+      await tx
+        .delete(schema.contentDatabaseBodyHydrationQueue)
+        .where(eq(schema.contentDatabaseBodyHydrationQueue.sourceId, sourceId));
+      await tx
+        .delete(schema.contentDatabaseSourceFields)
+        .where(eq(schema.contentDatabaseSourceFields.sourceId, sourceId));
+      await tx
+        .delete(schema.contentDatabaseSourceRows)
+        .where(eq(schema.contentDatabaseSourceRows.sourceId, sourceId));
+      await tx
+        .delete(schema.contentDatabaseSources)
+        .where(eq(schema.contentDatabaseSources.id, sourceId));
+      type RemainingLocalRow = {
+        documentId: string;
+        sourceDisplayKey: string | null;
+        sourceValuesJson: string | null;
+        sourceName: string;
+      };
+      const remainingLocalRows: RemainingLocalRow[] = documentIds.length
+        ? await tx
+            .select({
+              documentId: schema.contentDatabaseSourceRows.documentId,
+              sourceDisplayKey:
+                schema.contentDatabaseSourceRows.sourceDisplayKey,
+              sourceValuesJson:
+                schema.contentDatabaseSourceRows.sourceValuesJson,
+              sourceName: schema.contentDatabaseSources.sourceName,
+            })
+            .from(schema.contentDatabaseSourceRows)
+            .innerJoin(
+              schema.contentDatabaseSources,
+              eq(
+                schema.contentDatabaseSources.id,
+                schema.contentDatabaseSourceRows.sourceId,
+              ),
+            )
+            .where(
+              and(
+                inArray(
+                  schema.contentDatabaseSourceRows.documentId,
+                  documentIds,
+                ),
+                ne(schema.contentDatabaseSourceRows.sourceId, sourceId),
+                eq(
+                  schema.contentDatabaseSources.sourceType,
+                  LOCAL_FOLDER_SOURCE_TYPE,
+                ),
+              ),
+            )
+        : [];
+      const remainingLocalRowByDocument = new Map<string, RemainingLocalRow>(
+        remainingLocalRows.map((row) => [row.documentId, row]),
+      );
+      const documentsToClear = documentIds.filter(
+        (documentId) => !remainingLocalRowByDocument.has(documentId),
+      );
+      if (documentsToClear.length) {
+        await tx
+          .update(schema.documents)
+          .set({
+            sourceMode: "database",
+            sourceKind: null,
+            sourcePath: null,
+            sourceRootPath: null,
+            sourceUpdatedAt: now,
+            updatedAt: now,
+          })
+          .where(
+            and(
+              inArray(schema.documents.id, documentsToClear),
+              eq(schema.documents.spaceId, spaceId),
+            ),
+          );
+      }
+      for (const [documentId, remaining] of remainingLocalRowByDocument) {
+        const sourceValues = JSON.parse(remaining.sourceValuesJson || "{}") as {
+          relativePath?: unknown;
+        };
+        const relativePath =
+          typeof sourceValues.relativePath === "string"
+            ? sourceValues.relativePath
+            : remaining.sourceDisplayKey;
+        await tx
+          .update(schema.documents)
+          .set({
+            sourceMode: "local-files",
+            sourceKind: "file",
+            sourcePath: relativePath,
+            sourceRootPath: remaining.sourceName,
+            sourceUpdatedAt: now,
+            updatedAt: now,
+          })
+          .where(
+            and(
+              eq(schema.documents.id, documentId),
+              eq(schema.documents.spaceId, spaceId),
+            ),
+          );
+      }
+    });
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    return {
+      success: true,
+      sourceId,
+      disconnectedDocuments,
+      localFilesDeleted: 0,
+    };
+  },
+});

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

@@ -6,6 +6,7 @@ import { and, eq, gte, isNull, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { ensureDocumentFilesMembership } from "./_content-files.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
 import { nanoid } from "./_property-utils.js";
 
@@ -48,6 +49,12 @@ export default defineAction({
       );
 
     if (!row) throw new Error("Database row not found.");
+    if (!row.database.spaceId) {
+      throw new Error("Database does not belong to a Content space.");
+    }
+    if (row.document.spaceId !== row.database.spaceId) {
+      throw new Error("Cannot duplicate a database row across Content spaces.");
+    }
 
     await assertAccess("document", row.database.documentId, "editor");
     await assertAccess("document", row.document.id, "viewer");
@@ -103,6 +110,7 @@ export default defineAction({
 
       await tx.insert(schema.documents).values({
         id: nextDocumentId,
+        spaceId: row.database.spaceId,
         ownerEmail: row.document.ownerEmail,
         orgId: row.document.orgId,
         parentId: row.database.documentId,
@@ -155,6 +163,8 @@ export default defineAction({
           })),
         );
       }
+
+      await ensureDocumentFilesMembership(tx, nextDocumentId, now);
     });
 
     await writeAppState("refresh-signal", { ts: Date.now() });

package/corpus/templates/content/actions/duplicate-database-items.ts

@@ -5,6 +5,7 @@ import { assertAccess } from "@agent-native/core/sharing";
 import { and, eq, gte, inArray, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../server/db/index.js";
+import { ensureDocumentsFilesMembership } from "./_content-files.js";
 import {
   databaseRowBatchSchema,
   resolveDatabaseRowsForBatch,
@@ -19,6 +20,12 @@ export default defineAction({
   run: async (args) => {
     const db = getDb();
     const { database, rows } = await resolveDatabaseRowsForBatch(args);
+    if (!database.spaceId) {
+      throw new Error("Database does not belong to a Content space.");
+    }
+    if (rows.some((row) => row.document.spaceId !== database.spaceId)) {
+      throw new Error("Cannot duplicate database rows across Content spaces.");
+    }
 
     await assertAccess("document", database.documentId, "editor");
     for (const row of rows) {
@@ -103,6 +110,7 @@ export default defineAction({
       await tx.insert(schema.documents).values(
         duplicates.map((duplicate) => ({
           id: duplicate.duplicatedDocumentId,
+          spaceId: database.spaceId,
           ownerEmail: duplicate.row.document.ownerEmail,
           orgId: duplicate.row.document.orgId,
           parentId: database.documentId,
@@ -163,6 +171,11 @@ export default defineAction({
           ),
         );
       }
+      await ensureDocumentsFilesMembership(
+        tx,
+        duplicates.map((duplicate) => duplicate.duplicatedDocumentId),
+        now,
+      );
     });
 
     await writeAppState("refresh-signal", { ts: Date.now() });

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

@@ -10,11 +10,6 @@ import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import {
-  getLocalFileDocument,
-  isContentLocalFileMode,
-  updateLocalFileDocument,
-} from "./_local-file-documents.js";
 
 interface TextEdit {
   find: string;
@@ -72,19 +67,8 @@ export default defineAction({
       if (edit.replace === undefined) edit.replace = "";
     }
 
-    const localFileMode = await isContentLocalFileMode();
-    const existing = await (async () => {
-      if (localFileMode) {
-        const doc = await getLocalFileDocument(id);
-        if (doc.source?.kind === "folder") {
-          throw new Error("Folders cannot be edited directly");
-        }
-        return doc;
-      }
-
-      const access = await assertAccess("document", id, "editor");
-      return access.resource;
-    })();
+    const access = await assertAccess("document", id, "editor");
+    const existing = access.resource;
 
     // ─── Apply edits to the document markdown ───────────────────────────────
     //
@@ -128,16 +112,6 @@ export default defineAction({
       return { applied: 0, total: edits.length, results };
     }
 
-    if (localFileMode) {
-      await updateLocalFileDocument(id, { content });
-      await writeAppState("refresh-signal", { ts: Date.now() });
-      return {
-        applied: changeCount,
-        total: edits.length,
-        results,
-      };
-    }
-
     // Persist. The fresh updatedAt is the signal the open editor uses to tell an
     // intentional external edit apart from a stale autosave echo.
     const db = getDb();

package/corpus/templates/content/actions/ensure-content-spaces.ts

@@ -0,0 +1,26 @@
+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:
+    "Provision and reconcile the signed-in user's personal and organization Content spaces.",
+  schema: z.object({}),
+  run: async () => {
+    const userEmail = getRequestUserEmail();
+    if (!userEmail) throw new Error("no authenticated user");
+    const db = getDb();
+    const result = await provisionContentSpaces(db, userEmail);
+    const reconciliation = await reconcileContentFilesMemberships(
+      db,
+      userEmail,
+    );
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    return { ...result, reconciliation };
+  },
+});

package/corpus/templates/content/actions/export-content-source.ts

@@ -1,6 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { accessFilter } from "@agent-native/core/sharing";
-import { asc } from "drizzle-orm";
+import { and, asc, eq, inArray } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -10,13 +10,21 @@ import {
 } from "../server/lib/documents.js";
 import {
   buildContentSourceBundle,
+  serializeContentSourceDocument,
   type ContentSourceDocument,
 } from "../shared/content-source.js";
 
 export default defineAction({
   description:
     "Export editable Content documents as source-control friendly Markdown/MDX files with frontmatter.",
-  schema: z.object({}),
+  schema: z.object({
+    sourceId: z
+      .string()
+      .optional()
+      .describe(
+        "Connected local-folder source to export using its relative paths",
+      ),
+  }),
   http: { method: "GET" },
   readOnly: true,
   publicAgent: {
@@ -27,11 +35,28 @@ export default defineAction({
     description:
       "Export Content documents as a local-file source bundle for MDX workflows.",
   },
-  run: async () => {
-    const rows = await getDb()
+  run: async ({ sourceId }) => {
+    const db = getDb();
+    const sourceRows = sourceId
+      ? await db
+          .select()
+          .from(schema.contentDatabaseSourceRows)
+          .where(eq(schema.contentDatabaseSourceRows.sourceId, sourceId))
+      : [];
+    const sourceDocumentIds = sourceRows.map((row) => row.documentId);
+    const rows = await db
       .select()
       .from(schema.documents)
-      .where(accessFilter(schema.documents, schema.documentShares))
+      .where(
+        sourceId
+          ? sourceDocumentIds.length
+            ? and(
+                accessFilter(schema.documents, schema.documentShares),
+                inArray(schema.documents.id, sourceDocumentIds),
+              )
+            : eq(schema.documents.id, "__no_local_folder_documents__")
+          : accessFilter(schema.documents, schema.documentShares),
+      )
       .orderBy(asc(schema.documents.position), asc(schema.documents.title));
 
     const documents: ContentSourceDocument[] = rows.map((doc) => ({
@@ -48,9 +73,22 @@ export default defineAction({
       updatedAt: doc.updatedAt,
     }));
 
-    return {
-      ...buildContentSourceBundle(documents),
-      count: documents.length,
-    };
+    if (sourceId) {
+      const pathByDocumentId = new Map(
+        sourceRows.map((row) => [row.documentId, row.sourceDisplayKey]),
+      );
+      return {
+        root: "",
+        exportedAt: new Date().toISOString(),
+        files: Object.fromEntries(
+          documents.map((document) => [
+            pathByDocumentId.get(document.id) ?? `content/${document.id}.mdx`,
+            serializeContentSourceDocument(document),
+          ]),
+        ),
+        count: documents.length,
+      };
+    }
+    return { ...buildContentSourceBundle(documents), count: documents.length };
   },
 });

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

@@ -15,12 +15,6 @@ import {
   serializeDatabaseMembership,
 } from "./_database-utils.js";
 import { serializeDocumentSource } from "./_document-source.js";
-import {
-  getLocalFileDocument,
-  getLocalDocumentContextPath,
-  isLocalDocumentId,
-  isContentLocalFileMode,
-} from "./_local-file-documents.js";
 import "../server/db/index.js";
 import {
   listPropertiesForDocument,
@@ -46,14 +40,6 @@ export default defineAction({
   run: async (args) => {
     if (!args.id) throw new Error("--id is required");
 
-    if ((await isContentLocalFileMode()) && isLocalDocumentId(args.id)) {
-      const document = await getLocalFileDocument(args.id);
-      return {
-        ...document,
-        contextPath: await getLocalDocumentContextPath(args.id),
-      };
-    }
-
     const access = await resolveAccess("document", args.id);
     // Not-found is a deterministic client-state condition (deleted or
     // inaccessible document still referenced by an open tab) — 404, not a

package/corpus/templates/content/actions/import-content-source.ts

@@ -15,6 +15,13 @@ import {
   parseContentSourceFile,
   type ParsedContentSourceFile,
 } from "../shared/content-source.js";
+import { ensureDocumentsFilesMembership } from "./_content-files.js";
+import { resolveContentSpaceAccess } from "./_content-space-access.js";
+import {
+  organizationContentSpaceId,
+  personalContentSpaceId,
+  provisionContentSpaces,
+} from "./_content-spaces.js";
 
 const MAX_SOURCE_FILES = 500;
 const MAX_SOURCE_FILE_BYTES = 2 * 1024 * 1024;
@@ -187,6 +194,18 @@ export default defineAction({
     const currentOrgId = getRequestOrgId() ?? null;
     const db = getDb();
     const now = new Date().toISOString();
+    const defaultSpaceId = currentOrgId
+      ? organizationContentSpaceId(currentOrgId)
+      : personalContentSpaceId(currentUserEmail);
+    if (!dryRun) {
+      const provisioned = await provisionContentSpaces(db, currentUserEmail);
+      if (!provisioned.spaceIds.includes(defaultSpaceId)) {
+        throw new Error(
+          "The active organization does not have a writable Content space.",
+        );
+      }
+      await resolveContentSpaceAccess(defaultSpaceId, "editor");
+    }
     const parsed: ParsedContentSourceFile[] = entries.map(
       ([filePath, source]) => parseContentSourceFile(filePath, source),
     );
@@ -229,6 +248,7 @@ export default defineAction({
     const idByPath = new Map<string, string>();
     const pathById = new Map<string, string>();
     const ownerById = new Map<string, string>();
+    const spaceById = new Map<string, string>();
     const desiredParentById = new Map<string, string | null>();
     const desiredPositionById = new Map<string, number>();
     const currentParentById = new Map<string, string | null>();
@@ -271,7 +291,9 @@ export default defineAction({
       }
 
       if (existing) {
+        const existingSpaceId = existing.spaceId ?? defaultSpaceId;
         ownerById.set(id, existing.ownerEmail as string);
+        spaceById.set(id, existingSpaceId);
         currentParentById.set(id, existing.parentId ?? null);
         currentPositionById.set(id, existing.position ?? 0);
         if (file.parentId !== undefined) {
@@ -299,6 +321,7 @@ export default defineAction({
           existing.sourceKind !== sourceUpdates.sourceKind ||
           existing.sourcePath !== sourceUpdates.sourcePath ||
           existing.sourceRootPath !== sourceUpdates.sourceRootPath;
+        const spaceChanged = !existing.spaceId;
         const anyChange =
           titleChanged ||
           contentChanged ||
@@ -306,7 +329,8 @@ export default defineAction({
           iconChanged ||
           favoriteChanged ||
           discoverabilityChanged ||
-          sourceChanged;
+          sourceChanged ||
+          spaceChanged;
 
         if (!anyChange) {
           unchanged.push({ id, path: file.path, title: existing.title });
@@ -324,6 +348,7 @@ export default defineAction({
           }
 
           const updates: Record<string, unknown> = { updatedAt: now };
+          if (!existing.spaceId) updates.spaceId = existingSpaceId;
           if (titleChanged) updates.title = file.title;
           if (contentChanged) updates.content = file.content;
           if (descriptionChanged) updates.description = file.description;
@@ -348,6 +373,7 @@ export default defineAction({
         try {
           await db.insert(schema.documents).values({
             id,
+            spaceId: defaultSpaceId,
             ownerEmail: currentUserEmail,
             orgId: currentOrgId,
             parentId: null,
@@ -382,6 +408,7 @@ export default defineAction({
       desiredParentById.set(id, file.parentId ?? null);
       desiredPositionById.set(id, file.position ?? index);
       ownerById.set(id, currentUserEmail);
+      spaceById.set(id, defaultSpaceId);
       created.push({ id, path: file.path, title: file.title });
     }
 
@@ -410,7 +437,8 @@ export default defineAction({
           const parentAccess = await resolveAccess("document", parentId);
           if (
             parentAccess &&
-            (parentAccess.resource.ownerEmail as string) === ownerEmail
+            (parentAccess.resource.ownerEmail as string) === ownerEmail &&
+            parentAccess.resource.spaceId === spaceById.get(id)
           ) {
             try {
               await assertParentIsNotDescendant({ ownerEmail, id, parentId });
@@ -428,7 +456,7 @@ export default defineAction({
           } else {
             skipped.push({
               path: pathById.get(id) ?? id,
-              reason: `Skipped parent "${parentId}" because it is not editable in the same owner scope.`,
+              reason: `Skipped parent "${parentId}" because it is not editable in the same Content space.`,
             });
           }
         }
@@ -452,6 +480,18 @@ export default defineAction({
           .where(eq(schema.documents.id, id));
       }
 
+      await ensureDocumentsFilesMembership(
+        db,
+        [
+          ...new Set([
+            ...created.map((row) => row.id),
+            ...updated.map((row) => row.id),
+            ...unchanged.map((row) => row.id),
+          ]),
+        ],
+        now,
+      );
+
       await writeAppState("refresh-signal", { ts: Date.now() });
     }
 

package/corpus/templates/content/actions/list-content-spaces.ts

@@ -0,0 +1,103 @@
+import { defineAction } from "@agent-native/core";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { and, eq, isNull } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  listContentOrganizationMemberships,
+  normalizeContentSpaceEmail,
+} from "./_content-space-access.js";
+import {
+  personalContentSpaceId,
+  systemIdsForContentSpace,
+} from "./_content-spaces.js";
+
+export default defineAction({
+  description:
+    "List Content spaces that are already provisioned and currently authorized for the signed-in user.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async () => {
+    const userEmail = getRequestUserEmail();
+    if (!userEmail) throw new Error("no authenticated user");
+    const email = normalizeContentSpaceEmail(userEmail);
+    const db = getDb();
+    const personalSpaceId = personalContentSpaceId(email);
+    const catalogIds = systemIdsForContentSpace(personalSpaceId, "workspaces");
+    const memberships = await listContentOrganizationMemberships(email);
+    const roleByOrgId = new Map(
+      memberships.map((membership) => [
+        membership.orgId,
+        membership.role === "owner"
+          ? "owner"
+          : membership.role === "admin"
+            ? "editor"
+            : "viewer",
+      ]),
+    );
+    const rows = await db
+      .select({
+        mapping: schema.contentSpaceCatalogItems,
+        space: schema.contentSpaces,
+        item: schema.contentDatabaseItems,
+      })
+      .from(schema.contentSpaceCatalogItems)
+      .innerJoin(
+        schema.contentSpaces,
+        eq(schema.contentSpaces.id, schema.contentSpaceCatalogItems.spaceId),
+      )
+      .innerJoin(
+        schema.contentDatabaseItems,
+        eq(
+          schema.contentDatabaseItems.id,
+          schema.contentSpaceCatalogItems.databaseItemId,
+        ),
+      )
+      .where(
+        and(
+          eq(schema.contentSpaceCatalogItems.ownerEmail, email),
+          eq(
+            schema.contentSpaceCatalogItems.catalogDatabaseId,
+            catalogIds.databaseId,
+          ),
+          isNull(schema.contentSpaces.archivedAt),
+        ),
+      );
+    const spaces = [] as Array<{
+      id: string;
+      name: string;
+      kind: string;
+      filesDatabaseId: string;
+      orgId: string | null;
+      role: string;
+      catalogItemId: string;
+      catalogDocumentId: string;
+    }>;
+    for (const row of rows) {
+      if (
+        row.item.databaseId !== catalogIds.databaseId ||
+        row.item.documentId !== row.mapping.documentId
+      )
+        continue;
+      const role = row.space.orgId
+        ? roleByOrgId.get(row.space.orgId)
+        : row.space.ownerEmail.toLowerCase() === email
+          ? "owner"
+          : undefined;
+      if (!role) continue;
+      spaces.push({
+        id: row.space.id,
+        name: row.space.name,
+        kind: row.space.kind,
+        filesDatabaseId: row.space.filesDatabaseId,
+        orgId: row.space.orgId,
+        role,
+        catalogItemId: row.mapping.databaseItemId,
+        catalogDocumentId: row.mapping.documentId,
+      });
+    }
+    return { catalogDatabaseId: catalogIds.databaseId, spaces };
+  },
+});