@agent-native/core 0.101.6 → 0.101.10

package/corpus/templates/content/actions/_builder-cms-write-settings.ts

@@ -1,5 +1,4 @@
 import {
-  BUILDER_CMS_SAFE_WRITE_MODEL,
   type ContentDatabaseSourceCapabilities,
   type ContentDatabaseSourcePushMode,
   type ContentDatabaseSourceWriteMode,
@@ -126,6 +125,32 @@ function pushModeForTier(
   return "none";
 }
 
+function writeModeCopy(writeMode: ContentDatabaseSourceWriteMode) {
+  if (writeMode === "publish_updates") {
+    return {
+      pushModeLabel: "Publish updates",
+      pushModeDescription:
+        "Review, update, and publish existing Builder entries. New entries are never created by this mode.",
+      notes:
+        "Builder CMS source with reviewed update-in-place publication enabled for existing entries.",
+    };
+  }
+  if (writeMode === "stage_only") {
+    return {
+      pushModeLabel: "Stage only",
+      pushModeDescription:
+        "Prepare and review local revisions without writing to Builder.",
+      notes:
+        "Builder CMS source with local review staging enabled and remote writes disabled.",
+    };
+  }
+  return {
+    pushModeLabel: "Read only",
+    pushModeDescription: "Refresh and review Builder content without writing.",
+    notes: "Builder CMS source with remote writes disabled.",
+  };
+}
+
 export function builderCmsWriteSettingsFromJson(args: {
   capabilitiesJson: string | null | undefined;
   metadataJson: string | null | undefined;
@@ -178,11 +203,6 @@ export function buildBuilderCmsWriteModeJson(
         "Live writes can only be enabled for Builder CMS sources.",
       );
     }
-    if (args.sourceTable !== BUILDER_CMS_SAFE_WRITE_MODEL) {
-      throw new Error(
-        `Live Builder writes are only allowed for ${BUILDER_CMS_SAFE_WRITE_MODEL}.`,
-      );
-    }
   }
 
   if (
@@ -199,6 +219,7 @@ export function buildBuilderCmsWriteModeJson(
   };
   const nextMetadata: Record<string, unknown> = {
     ...metadata,
+    ...writeModeCopy(writeMode),
     writeMode,
     allowPublicationTransitions,
     allowedWriteModes,
@@ -226,7 +247,6 @@ export function mergeBuilderCmsWriteSettingsIntoJson(args: {
   });
   if (
     currentSettings.liveWritesEnabled !== true ||
-    args.sourceTable !== BUILDER_CMS_SAFE_WRITE_MODEL ||
     currentSettings.writeMode === "read_only"
   ) {
     return {

package/corpus/templates/content/actions/_builder-source-execution-claim.ts

@@ -0,0 +1,124 @@
+import { createHash } from "node:crypto";
+
+import { and, eq } from "drizzle-orm";
+
+import { getDb, schema } from "../server/db/index.js";
+import { builderExecutionHasResponseEvidence } from "./_builder-source-execution-preservation.js";
+
+function claimId(sourceId: string, idempotencyKey: string) {
+  return createHash("sha256")
+    .update(`${sourceId}\u0000${idempotencyKey}`)
+    .digest("hex");
+}
+
+function evidenceRank(row: {
+  state: string;
+  payloadJson: string;
+  updatedAt: string;
+  id: string;
+}) {
+  const stateRank =
+    row.state === "succeeded"
+      ? 0
+      : row.state === "response_received"
+        ? 1
+        : row.state === "reconciliation_required"
+          ? 2
+          : builderExecutionHasResponseEvidence(row.payloadJson)
+            ? 3
+            : row.state === "running"
+              ? 4
+              : 5;
+  return { stateRank, updatedAt: row.updatedAt, id: row.id };
+}
+
+function canonicalExecution<
+  T extends {
+    state: string;
+    payloadJson: string;
+    updatedAt: string;
+    id: string;
+  },
+>(rows: T[]) {
+  return [...rows].sort((left, right) => {
+    const a = evidenceRank(left);
+    const b = evidenceRank(right);
+    return (
+      a.stateRank - b.stateRank ||
+      b.updatedAt.localeCompare(a.updatedAt) ||
+      a.id.localeCompare(b.id)
+    );
+  })[0];
+}
+
+export async function claimBuilderSourceExecutionGate(args: {
+  ownerEmail: string;
+  sourceId: string;
+  idempotencyKey: string;
+  now: string;
+}) {
+  const db = getDb();
+  const whereKey = and(
+    eq(schema.contentDatabaseSourceExecutionClaims.ownerEmail, args.ownerEmail),
+    eq(schema.contentDatabaseSourceExecutionClaims.sourceId, args.sourceId),
+    eq(
+      schema.contentDatabaseSourceExecutionClaims.idempotencyKey,
+      args.idempotencyKey,
+    ),
+  );
+  const [existingClaim] = await db
+    .select()
+    .from(schema.contentDatabaseSourceExecutionClaims)
+    .where(whereKey)
+    .limit(1);
+  if (existingClaim) return existingClaim.executionId;
+
+  const candidates = await db
+    .select()
+    .from(schema.contentDatabaseSourceExecutions)
+    .where(
+      and(
+        eq(schema.contentDatabaseSourceExecutions.ownerEmail, args.ownerEmail),
+        eq(schema.contentDatabaseSourceExecutions.sourceId, args.sourceId),
+        eq(
+          schema.contentDatabaseSourceExecutions.idempotencyKey,
+          args.idempotencyKey,
+        ),
+      ),
+    );
+  const canonical = canonicalExecution(candidates);
+  const executionId = canonical?.id ?? crypto.randomUUID();
+
+  try {
+    await db.insert(schema.contentDatabaseSourceExecutionClaims).values({
+      id: claimId(args.sourceId, args.idempotencyKey),
+      ownerEmail: args.ownerEmail,
+      sourceId: args.sourceId,
+      idempotencyKey: args.idempotencyKey,
+      executionId,
+      createdAt: args.now,
+    });
+  } catch (error) {
+    const [winner] = await db
+      .select()
+      .from(schema.contentDatabaseSourceExecutionClaims)
+      .where(whereKey)
+      .limit(1);
+    if (!winner) throw error;
+    return winner.executionId;
+  }
+
+  if (candidates.length > 1 && canonical) {
+    await db
+      .update(schema.contentDatabaseSourceExecutions)
+      .set({
+        state: "reconciliation_required",
+        summary: "Duplicate execution gates require reconciliation.",
+        lastError:
+          "Multiple execution rows exist for this idempotency key. Evidence was preserved; do not retry.",
+        updatedAt: args.now,
+      })
+      .where(eq(schema.contentDatabaseSourceExecutions.id, canonical.id));
+  }
+  return executionId;
+}

package/corpus/templates/content/actions/_builder-source-execution-preservation.ts

@@ -0,0 +1,21 @@
+export function builderExecutionHasResponseEvidence(payloadJson: string) {
+  try {
+    const payload = JSON.parse(payloadJson) as Record<string, unknown>;
+    return Boolean(payload.response && typeof payload.response === "object");
+  } catch {
+    return false;
+  }
+}
+
+export function shouldPreserveBuilderExecution(args: {
+  state: string;
+  payloadJson: string;
+}) {
+  return (
+    args.state === "running" ||
+    args.state === "response_received" ||
+    args.state === "reconciliation_required" ||
+    args.state === "succeeded" ||
+    builderExecutionHasResponseEvidence(args.payloadJson)
+  );
+}

package/corpus/templates/content/actions/_builder-source-timings.ts

@@ -0,0 +1,57 @@
+import type { BuilderActionTiming } from "../shared/api.js";
+
+type Clock = () => number;
+
+function defaultClock() {
+  return performance.now();
+}
+
+export function createBuilderSourceTiming(
+  action: string,
+  clock: Clock = defaultClock,
+) {
+  const actionStartedAt = clock();
+  const timings: BuilderActionTiming[] = [];
+
+  function record(name: string, startedAt: number) {
+    const durationMs = Math.max(0, clock() - startedAt);
+    timings.push({ name, durationMs });
+  }
+
+  async function measure<T>(name: string, operation: () => Promise<T>) {
+    const startedAt = clock();
+    try {
+      return await operation();
+    } finally {
+      record(name, startedAt);
+    }
+  }
+
+  function ensure(name: string) {
+    if (!timings.some((timing) => timing.name === name)) {
+      timings.push({ name, durationMs: 0 });
+    }
+  }
+
+  function add(name: string, durationMs: number) {
+    const safeDurationMs = Math.max(0, durationMs);
+    timings.push({ name, durationMs: safeDurationMs });
+  }
+
+  function finish() {
+    if (!timings.some((timing) => timing.name === "total")) {
+      record("total", actionStartedAt);
+    }
+    return timings.map((timing) => ({ ...timing }));
+  }
+
+  function log(outcome: "succeeded" | "failed") {
+    console.info("builder_source_action_timing", {
+      action,
+      outcome,
+      timings: finish(),
+    });
+  }
+
+  return { start: clock, record, measure, add, ensure, finish, log };
+}