@agent-native/core 0.101.7 → 0.101.10

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

@@ -36,6 +36,32 @@ type DatabaseMembershipRow = {
   bodyHydrationQueueId?: string | null;
 };
 
+type DocumentListRow = Omit<typeof schema.documents.$inferSelect, "content">;
+
+// Database grids render row metadata and properties. Fetching the document body
+// here would transfer it only for serializeDocument to replace it with an empty
+// string below; opened documents use their dedicated document read path instead.
+export const contentDatabaseListDocumentSelection = {
+  id: schema.documents.id,
+  parentId: schema.documents.parentId,
+  title: schema.documents.title,
+  description: schema.documents.description,
+  icon: schema.documents.icon,
+  position: schema.documents.position,
+  isFavorite: schema.documents.isFavorite,
+  hideFromSearch: schema.documents.hideFromSearch,
+  sourceMode: schema.documents.sourceMode,
+  sourceKind: schema.documents.sourceKind,
+  sourcePath: schema.documents.sourcePath,
+  sourceRootPath: schema.documents.sourceRootPath,
+  sourceUpdatedAt: schema.documents.sourceUpdatedAt,
+  visibility: schema.documents.visibility,
+  ownerEmail: schema.documents.ownerEmail,
+  orgId: schema.documents.orgId,
+  createdAt: schema.documents.createdAt,
+  updatedAt: schema.documents.updatedAt,
+};
+
 export function serializeBodyHydration(
   item: typeof schema.contentDatabaseItems.$inferSelect,
   options: { queued?: boolean } = {},
@@ -46,6 +72,7 @@ export function serializeBodyHydration(
       status === "pending" ||
       status === "hydrating" ||
       status === "hydrated" ||
+      status === "unavailable" ||
       status === "error"
         ? status
         : options.queued
@@ -123,16 +150,61 @@ export function normalizeContentDatabasePageOptions(options: {
   return { limit, offset };
 }
 
+export function filterContentDatabaseSourceRowsForPage<
+  TRow extends { documentId: string; databaseItemId: string },
+  TChangeSet extends {
+    documentId: string | null;
+    databaseItemId: string | null;
+    direction: string;
+    state: string;
+    executions: Array<{ state: string }>;
+  },
+>(args: {
+  rows: TRow[];
+  changeSets: TChangeSet[];
+  visibleDocumentIds: ReadonlySet<string>;
+}) {
+  const actionableChangeSets = args.changeSets.filter(
+    (changeSet) =>
+      changeSet.direction === "outbound" &&
+      !changeSet.executions.some(
+        (execution) => execution.state === "succeeded",
+      ) &&
+      (changeSet.state === "pending_push" ||
+        changeSet.state === "staged_revision" ||
+        changeSet.state === "approved"),
+  );
+  const actionableDocumentIds = new Set(
+    actionableChangeSets.flatMap((changeSet) =>
+      changeSet.documentId ? [changeSet.documentId] : [],
+    ),
+  );
+  const actionableItemIds = new Set(
+    actionableChangeSets.flatMap((changeSet) =>
+      changeSet.databaseItemId ? [changeSet.databaseItemId] : [],
+    ),
+  );
+
+  return args.rows.filter(
+    (row) =>
+      !row.documentId ||
+      args.visibleDocumentIds.has(row.documentId) ||
+      actionableDocumentIds.has(row.documentId) ||
+      actionableItemIds.has(row.databaseItemId),
+  );
+}
+
 function serializeDocument(
-  doc: typeof schema.documents.$inferSelect,
+  doc: DocumentListRow,
   membership?: DatabaseMembershipRow,
-  options: { includeContent?: boolean } = {},
 ) {
   return {
     id: doc.id,
     parentId: doc.parentId,
     title: doc.title,
-    content: options.includeContent === true ? doc.content : "",
+    // List reads deliberately project no `documents.content`; opened documents
+    // use their dedicated read path.
+    content: "",
     description: doc.description,
     icon: doc.icon,
     position: doc.position,
@@ -196,7 +268,7 @@ export async function getContentDatabaseResponse(
   const documents =
     items.length > 0
       ? await db
-          .select()
+          .select(contentDatabaseListDocumentSelection)
           .from(schema.documents)
           .where(
             and(
@@ -211,7 +283,9 @@ export async function getContentDatabaseResponse(
   const documentById = new Map(documents.map((doc) => [doc.id, doc]));
   const propertiesByDocumentId = await listPropertiesForDatabaseDocuments(
     databaseId,
-    documents,
+    // Property serialization uses metadata only; this list projection carries
+    // every document field it consumes except the deliberately omitted body.
+    documents as Array<typeof schema.documents.$inferSelect>,
   );
   const queuedBodyHydrationItemIds =
     items.length > 0
@@ -259,17 +333,20 @@ export async function getContentDatabaseResponse(
     serializedItems.map((item) => item.document.id),
   );
   // When paginating, scope every DOCUMENT-BACKED source's rows to the visible
-  // page — that's the primary AND any row-union secondary (each row maps to a
-  // real document). Federated join rows carry no document (empty documentId),
-  // so they're kept intact — only matched ones overlay anyway.
+  // page, plus the small set referenced by actionable reviews. The dialog gets
+  // change sets independently of the item page and needs those rows to retain
+  // the linked provider target instead of misclassifying an off-page update as
+  // a create. Federated join rows carry no document (empty documentId), so
+  // they're kept intact — only matched ones overlay anyway.
   const pagedSources =
     limit !== null
       ? sources.map((source) => ({
           ...source,
-          rows: source.rows.filter(
-            (row) =>
-              !row.documentId || serializedDocumentIds.has(row.documentId),
-          ),
+          rows: filterContentDatabaseSourceRowsForPage({
+            rows: source.rows,
+            changeSets: source.changeSets,
+            visibleDocumentIds: serializedDocumentIds,
+          }),
         }))
       : sources;
   const pagedPrimary = pagedSources[0] ?? null;

package/corpus/templates/content/actions/_preview-document-draft.ts

@@ -0,0 +1,31 @@
+import { and, eq } from "drizzle-orm";
+
+import { getDb, schema } from "../server/db/index.js";
+
+export async function readPreviewDocumentDraft(
+  ownerEmail: string,
+  orgId: string,
+  documentId: string,
+) {
+  const [draft] = await getDb()
+    .select({
+      documentId: schema.documentPreviewDrafts.documentId,
+      title: schema.documentPreviewDrafts.title,
+      content: schema.documentPreviewDrafts.content,
+      baseDocumentUpdatedAt: schema.documentPreviewDrafts.baseDocumentUpdatedAt,
+      loadedContentWasEmpty: schema.documentPreviewDrafts.loadedContentWasEmpty,
+      deferredReason: schema.documentPreviewDrafts.deferredReason,
+      version: schema.documentPreviewDrafts.version,
+      updatedAt: schema.documentPreviewDrafts.updatedAt,
+    })
+    .from(schema.documentPreviewDrafts)
+    .where(
+      and(
+        eq(schema.documentPreviewDrafts.ownerEmail, ownerEmail),
+        eq(schema.documentPreviewDrafts.orgId, orgId),
+        eq(schema.documentPreviewDrafts.documentId, documentId),
+      ),
+    )
+    .limit(1);
+  return draft ?? null;
+}

package/corpus/templates/content/actions/cancel-prepared-builder-source-update.ts

@@ -0,0 +1,309 @@
+import { defineAction } from "@agent-native/core";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, inArray } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import type {
+  CancelPreparedBuilderSourceUpdateRequest,
+  CancelPreparedBuilderSourceUpdateResponse,
+} from "../shared/api.js";
+import {
+  CANCELLED_BUILDER_EXECUTION_SUMMARY,
+  CANCELLED_BUILDER_REVIEW_NOTE_PREFIX,
+  resolveDatabaseForSourceMutation,
+} from "./_database-source-utils.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
+
+const PRE_DISPATCH_STATES = new Set(["ready", "write_disabled", "blocked"]);
+
+function parseExecutionPayload(payloadJson: string) {
+  let payload: unknown;
+  try {
+    payload = JSON.parse(payloadJson);
+  } catch {
+    throw new Error(
+      "Cannot cancel this Builder update because its execution evidence is unreadable.",
+    );
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error(
+      "Cannot cancel this Builder update because its execution evidence is ambiguous.",
+    );
+  }
+  return payload as Record<string, unknown>;
+}
+
+function isLocalBlockedDryRun(payload: Record<string, unknown>) {
+  const dryRun = payload.dryRun;
+  return (
+    !!dryRun &&
+    typeof dryRun === "object" &&
+    !Array.isArray(dryRun) &&
+    (dryRun as Record<string, unknown>).status === "blocked"
+  );
+}
+
+function assertProvablyPreDispatch(execution: {
+  state: string;
+  summary: string;
+  payloadJson: string;
+  attemptToken: string | null;
+}) {
+  if (!PRE_DISPATCH_STATES.has(execution.state)) {
+    throw new Error(
+      `Cannot cancel a Builder execution in state ${execution.state}. Its outcome must be preserved.`,
+    );
+  }
+  if (execution.attemptToken) {
+    throw new Error(
+      "Cannot cancel this Builder update because a dispatch attempt was recorded.",
+    );
+  }
+
+  const payload = parseExecutionPayload(execution.payloadJson);
+  if (
+    Object.prototype.hasOwnProperty.call(payload, "response") ||
+    Object.prototype.hasOwnProperty.call(payload, "dispatch")
+  ) {
+    throw new Error(
+      "Cannot cancel this Builder update because dispatch or response evidence was recorded.",
+    );
+  }
+  if (
+    execution.state === "blocked" &&
+    execution.summary !== CANCELLED_BUILDER_EXECUTION_SUMMARY &&
+    !isLocalBlockedDryRun(payload)
+  ) {
+    throw new Error(
+      "Cannot cancel this blocked Builder update because it is not provably a local pre-dispatch block.",
+    );
+  }
+}
+
+function assertCanonicalClaims(
+  executions: Array<{ id: string; idempotencyKey: string }>,
+  claims: Array<{ idempotencyKey: string; executionId: string }>,
+) {
+  const idempotencyKeys = executions.map((row) => row.idempotencyKey);
+  if (new Set(idempotencyKeys).size !== executions.length) {
+    throw new Error(
+      "Cannot cancel this Builder update because duplicate execution gates share an idempotency key.",
+    );
+  }
+  if (claims.length !== executions.length) {
+    throw new Error(
+      "Cannot cancel this Builder update because its canonical execution claim is missing or foreign.",
+    );
+  }
+  const claimByKey = new Map(
+    claims.map((claim) => [claim.idempotencyKey, claim.executionId]),
+  );
+  for (const execution of executions) {
+    if (claimByKey.get(execution.idempotencyKey) !== execution.id) {
+      throw new Error(
+        "Cannot cancel this Builder update because an execution claim points to a different gate.",
+      );
+    }
+  }
+}
+
+export default defineAction({
+  description:
+    "Cancel one exact prepared Builder update only when every execution is provably pre-dispatch. This never calls Builder or deletes audit history.",
+  schema: z
+    .object({
+      databaseId: z.string().optional().describe("Database ID"),
+      documentId: z.string().optional().describe("Database document/page ID"),
+      sourceId: z.string().describe("Exact Builder source ID"),
+      changeSetId: z.string().describe("Exact prepared Builder change-set ID"),
+      note: z
+        .string()
+        .max(500)
+        .optional()
+        .describe("Optional cancellation note"),
+    })
+    .refine((value) => value.databaseId || value.documentId, {
+      message: "Provide databaseId or documentId.",
+    }),
+  run: async (
+    args: CancelPreparedBuilderSourceUpdateRequest,
+  ): Promise<CancelPreparedBuilderSourceUpdateResponse> => {
+    const database = await resolveDatabaseForSourceMutation(args);
+    if (!database) throw new Error("Database not found.");
+    await assertAccess("document", database.documentId, "editor");
+
+    const db = getDb();
+    const actor = getRequestUserEmail() ?? "agent-runtime@agent-native.local";
+    const now = new Date().toISOString();
+    let executionIds: string[] = [];
+    let status: "cancelled" | "already_cancelled" = "cancelled";
+
+    await db.transaction(async (tx) => {
+      const [source] = await tx
+        .select()
+        .from(schema.contentDatabaseSources)
+        .where(
+          and(
+            eq(schema.contentDatabaseSources.id, args.sourceId),
+            eq(schema.contentDatabaseSources.databaseId, database.id),
+          ),
+        )
+        .limit(1);
+      if (!source || source.sourceType !== "builder-cms") {
+        throw new Error("The exact Builder source was not found.");
+      }
+
+      const [changeSet] = await tx
+        .select()
+        .from(schema.contentDatabaseSourceChangeSets)
+        .where(
+          and(
+            eq(schema.contentDatabaseSourceChangeSets.id, args.changeSetId),
+            eq(schema.contentDatabaseSourceChangeSets.sourceId, source.id),
+          ),
+        )
+        .limit(1);
+      if (!changeSet) throw new Error("Source change-set not found.");
+
+      const executions = await tx
+        .select()
+        .from(schema.contentDatabaseSourceExecutions)
+        .where(
+          and(
+            eq(schema.contentDatabaseSourceExecutions.sourceId, source.id),
+            eq(
+              schema.contentDatabaseSourceExecutions.changeSetId,
+              changeSet.id,
+            ),
+          ),
+        );
+      executionIds = executions.map((execution) => execution.id);
+
+      if (executions.length === 0) {
+        throw new Error("No prepared Builder execution was found to cancel.");
+      }
+      for (const execution of executions) assertProvablyPreDispatch(execution);
+
+      const idempotencyKeys = [
+        ...new Set(executions.map((row) => row.idempotencyKey)),
+      ];
+      const claims = await tx
+        .select({
+          idempotencyKey:
+            schema.contentDatabaseSourceExecutionClaims.idempotencyKey,
+          executionId: schema.contentDatabaseSourceExecutionClaims.executionId,
+        })
+        .from(schema.contentDatabaseSourceExecutionClaims)
+        .where(
+          and(
+            eq(
+              schema.contentDatabaseSourceExecutionClaims.ownerEmail,
+              database.ownerEmail,
+            ),
+            eq(schema.contentDatabaseSourceExecutionClaims.sourceId, source.id),
+            inArray(
+              schema.contentDatabaseSourceExecutionClaims.idempotencyKey,
+              idempotencyKeys,
+            ),
+          ),
+        );
+      assertCanonicalClaims(executions, claims);
+
+      if (changeSet.state === "rejected") {
+        const cancellationReviews = await tx
+          .select()
+          .from(schema.contentDatabaseSourceChangeReviews)
+          .where(
+            and(
+              eq(schema.contentDatabaseSourceChangeReviews.sourceId, source.id),
+              eq(
+                schema.contentDatabaseSourceChangeReviews.changeSetId,
+                changeSet.id,
+              ),
+              eq(
+                schema.contentDatabaseSourceChangeReviews.decision,
+                "rejected",
+              ),
+            ),
+          );
+        const wasCancelled =
+          executions.length > 0 &&
+          executions.every(
+            (execution) =>
+              execution.state === "blocked" &&
+              execution.summary === CANCELLED_BUILDER_EXECUTION_SUMMARY,
+          ) &&
+          cancellationReviews.some((review) =>
+            review.note?.startsWith(CANCELLED_BUILDER_REVIEW_NOTE_PREFIX),
+          );
+        if (!wasCancelled) {
+          throw new Error(
+            "This Builder change-set was rejected through another review path, not cancelled as a prepared update.",
+          );
+        }
+        status = "already_cancelled";
+        return;
+      }
+
+      if (changeSet.state !== "approved") {
+        throw new Error(
+          `Only an approved, prepared Builder change-set can be cancelled; current state is ${changeSet.state}.`,
+        );
+      }
+
+      await tx
+        .update(schema.contentDatabaseSourceExecutions)
+        .set({
+          state: "blocked",
+          summary: CANCELLED_BUILDER_EXECUTION_SUMMARY,
+          lastError: null,
+          updatedAt: now,
+        })
+        .where(
+          and(
+            eq(schema.contentDatabaseSourceExecutions.sourceId, source.id),
+            eq(
+              schema.contentDatabaseSourceExecutions.changeSetId,
+              changeSet.id,
+            ),
+          ),
+        );
+
+      const noteSuffix = args.note?.trim() ? ` Note: ${args.note.trim()}` : "";
+      await tx.insert(schema.contentDatabaseSourceChangeReviews).values({
+        id: crypto.randomUUID(),
+        ownerEmail: database.ownerEmail,
+        sourceId: source.id,
+        changeSetId: changeSet.id,
+        reviewerEmail: actor,
+        decision: "rejected",
+        stateFrom: changeSet.state,
+        stateTo: "rejected",
+        note: `${CANCELLED_BUILDER_REVIEW_NOTE_PREFIX} by ${actor} at ${now}.${noteSuffix}`,
+        createdAt: now,
+      });
+      await tx
+        .update(schema.contentDatabaseSourceChangeSets)
+        .set({ state: "rejected", updatedAt: now })
+        .where(eq(schema.contentDatabaseSourceChangeSets.id, changeSet.id));
+      await tx
+        .update(schema.contentDatabaseSources)
+        .set({ updatedAt: now })
+        .where(eq(schema.contentDatabaseSources.id, source.id));
+    });
+
+    return {
+      ...(await getContentDatabaseResponse(database.id)),
+      cancellation: {
+        sourceId: args.sourceId,
+        changeSetId: args.changeSetId,
+        executionIds,
+        status,
+        cancelledAt: now,
+        cancelledBy: actor,
+      },
+    };
+  },
+});