@agent-native/core 0.157.1 → 0.157.3

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8241
+- template files: 8242

package/corpus/templates/calendar/server/handlers/bookings.ts

@@ -483,7 +483,12 @@ async function resolveAvailabilityContext({
             draft
               ? and(
                   eq(schema.bookingLinks.slug, slug),
-                  accessFilter(schema.bookingLinks, schema.bookingLinkShares),
+                  accessFilter(
+                    schema.bookingLinks,
+                    schema.bookingLinkShares,
+                    undefined,
+                    "editor",
+                  ),
                 )
               : eq(schema.bookingLinks.slug, slug),
           )

package/corpus/templates/clips/actions/request-recording-access.ts

@@ -1,3 +1,5 @@
+import { createHash } from "node:crypto";
+
 import { defineAction } from "@agent-native/core";
 import { notify } from "@agent-native/core/notifications";
 import {
@@ -19,7 +21,7 @@ import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { nanoid, normalizeOwnerEmail } from "../server/lib/recordings.js";
+import { normalizeOwnerEmail } from "../server/lib/recordings.js";
 import {
   CLIPS_ACCESS_REQUEST_TOKEN_PREFIX,
   recordingSharePath,
@@ -27,6 +29,20 @@ import {
 
 export const CLIPS_ACCESS_REQUEST_EMAIL_ID = "clips.access-request";
 
+function accessRequestEventId(
+  recordingId: string,
+  requesterEmail: string,
+): string {
+  return (
+    "access-request-" +
+    createHash("sha256")
+      .update(recordingId)
+      .update("\0")
+      .update(requesterEmail)
+      .digest("hex")
+  );
+}
+
 function httpError(message: string, statusCode: number): Error {
   return Object.assign(new Error(message), { statusCode });
 }
@@ -211,19 +227,36 @@ export default defineAction({
       getRequestUserName()?.trim() ||
       displayNameForEmail(normalizedRequesterEmail);
     const requestedAt = new Date().toISOString();
-    await db.insert(schema.recordingEvents).values({
-      id: nanoid(),
-      recordingId,
-      viewerId: null,
-      kind: "access-request",
-      timestampMs: 0,
-      payload: JSON.stringify({
-        requesterEmail: normalizedRequesterEmail,
-        requesterName,
-        requestedAt,
-      }),
-      createdAt: requestedAt,
-    });
+    const [insertedRequest] = await db
+      .insert(schema.recordingEvents)
+      .values({
+        id: accessRequestEventId(recordingId, normalizedRequesterEmail),
+        recordingId,
+        viewerId: null,
+        kind: "access-request",
+        timestampMs: 0,
+        payload: JSON.stringify({
+          requesterEmail: normalizedRequesterEmail,
+          requesterName,
+          requestedAt,
+        }),
+        createdAt: requestedAt,
+      })
+      .onConflictDoNothing()
+      .returning({ id: schema.recordingEvents.id });
+
+    // Historical requests use random IDs, so the read above still handles
+    // them. New requests use a deterministic primary key so concurrent
+    // callers have one database-backed winner before notifications are sent.
+    if (!insertedRequest) {
+      return {
+        ok: true as const,
+        alreadyHasAccess: false,
+        alreadyRequested: true,
+        notifiedOwner: false,
+        message: "Your access request is already with the clip owner.",
+      };
+    }
 
     const ownerEmail = recording.ownerEmail
       ? normalizeOwnerEmail(recording.ownerEmail)

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/reset-chunks.post.ts

@@ -57,6 +57,7 @@ import {
   deleteResumableSession,
   getResumableSession,
   setResumableSession,
+  type StoredResumableSession,
 } from "../../../../lib/resumable-session.js";
 import { abortResumableUploadSession } from "../../../../lib/resumable-upload-cleanup.js";
 import { shouldEnableStreamingUpload } from "../../../../lib/streaming-upload-mode.js";
@@ -74,6 +75,66 @@ interface CompressionMeta {
   outputMimeType?: string;
 }
 
+interface PendingResumableCleanup {
+  recordingId: string;
+  generationId: string | null;
+  ownerGenerationId: string | null;
+  claimId: string | null;
+  session: StoredResumableSession;
+}
+
+function parsePendingResumableCleanup(
+  raw: Record<string, unknown> | null,
+  recordingId: string,
+): PendingResumableCleanup | null {
+  if (!raw) return null;
+  const session = raw.session;
+  const generationId = raw.generationId;
+  const ownerGenerationId = raw.ownerGenerationId;
+  const claimId = raw.claimId;
+  if (
+    raw.recordingId !== recordingId ||
+    !session ||
+    typeof session !== "object" ||
+    Array.isArray(session) ||
+    !(generationId === null || typeof generationId === "string") ||
+    (ownerGenerationId !== undefined &&
+      ownerGenerationId !== null &&
+      typeof ownerGenerationId !== "string") ||
+    (claimId !== undefined && claimId !== null && typeof claimId !== "string")
+  ) {
+    throw new Error(
+      `Invalid resumable cleanup state for recording ${recordingId}`,
+    );
+  }
+
+  const candidate = session as Record<string, unknown>;
+  if (
+    typeof candidate.providerId !== "string" ||
+    typeof candidate.sessionId !== "string" ||
+    !candidate.meta ||
+    typeof candidate.meta !== "object" ||
+    Array.isArray(candidate.meta) ||
+    typeof candidate.bytesUploaded !== "number" ||
+    !Number.isFinite(candidate.bytesUploaded) ||
+    (candidate.lastCommittedIndex !== undefined &&
+      typeof candidate.lastCommittedIndex !== "number")
+  ) {
+    throw new Error(
+      `Invalid resumable session in cleanup state for recording ${recordingId}`,
+    );
+  }
+
+  return {
+    recordingId,
+    generationId,
+    ownerGenerationId:
+      ownerGenerationId === undefined ? null : ownerGenerationId,
+    claimId: claimId === undefined ? null : claimId,
+    session: candidate as unknown as StoredResumableSession,
+  };
+}
+
 function normalizeVideoMimeType(value: unknown): string | null {
   if (typeof value !== "string") return null;
   const mimeType = value.split(";")[0]?.trim().toLowerCase();
@@ -219,10 +280,25 @@ export default defineEventHandler(async (event: H3Event) => {
     const nextGenerationId = useGenerationFence ? randomUUID() : null;
     const uploadStateKey = `recording-upload-${recordingId}`;
     const uploadStateSnapshot = await readAppState(uploadStateKey);
-    const discardedResumableSession = await getResumableSession(
+    const cleanupStateKey = `recording-resumable-cleanup-${recordingId}`;
+    const cleanupStateSnapshot = await readAppState(cleanupStateKey);
+    const parsedCleanup = parsePendingResumableCleanup(
+      cleanupStateSnapshot,
       recordingId,
-      existingGenerationId,
     );
+    const pendingCleanup =
+      parsedCleanup &&
+      (parsedCleanup.ownerGenerationId === null
+        ? !useGenerationFence
+        : parsedCleanup.ownerGenerationId === existingGenerationId)
+        ? parsedCleanup
+        : null;
+    const discardedGenerationId = pendingCleanup
+      ? pendingCleanup.generationId
+      : existingGenerationId;
+    const discardedResumableSession =
+      pendingCleanup?.session ??
+      (await getResumableSession(recordingId, existingGenerationId));
     const reset = await db
       .update(schema.recordings)
       .set({
@@ -257,29 +333,63 @@ export default defineEventHandler(async (event: H3Event) => {
       };
     }
 
+    let cleanupClaim: PendingResumableCleanup | null = null;
     if (discardedResumableSession) {
-      const cleaned = await abortResumableUploadSession(
-        discardedResumableSession,
-        { label: `reset-${recordingId}` },
+      // A cleanup claim belongs to the generation that won this fence. A
+      // losing reset must never resurrect a claim after the winner releases
+      // it, and a later winner must be able to transfer an unfinished claim.
+      const candidate: PendingResumableCleanup = {
+        recordingId,
+        generationId: discardedGenerationId,
+        ownerGenerationId: nextGenerationId,
+        claimId: randomUUID(),
+        session: discardedResumableSession,
+      };
+      const claimed = await compareAndSetAppState(
+        cleanupStateKey,
+        cleanupStateSnapshot,
+        candidate as unknown as Record<string, unknown>,
       );
-      if (!cleaned) {
-        setResponseStatus(event, 502);
-        return {
-          error:
-            "The previous recording upload could not be cleaned up. Retry the upload restart.",
-        };
+      if (claimed) cleanupClaim = candidate;
+    }
+
+    if (discardedResumableSession) {
+      if (cleanupClaim) {
+        const cleaned = await abortResumableUploadSession(
+          discardedResumableSession,
+          { label: `reset-${recordingId}` },
+        );
+        if (!cleaned) {
+          setResponseStatus(event, 502);
+          return {
+            error:
+              "The previous recording upload could not be cleaned up. Retry the upload restart.",
+          };
+        }
+        const released = await compareAndSetAppState(
+          cleanupStateKey,
+          cleanupClaim as unknown as Record<string, unknown>,
+          null,
+        );
+        if (!released) {
+          console.warn(
+            `[reset-chunks-${recordingId}] cleanup claim changed while releasing it`,
+          );
+        }
       }
     }
     const cleared = await deleteRecordingChunks(
       ownerEmail,
       recordingId,
-      existingGenerationId,
+      discardedGenerationId,
     );
     // Clear any stale resumable session so a buffered retry does not
     // accidentally route through handleResumableChunk with stale offsets.
-    await deleteResumableSession(recordingId, existingGenerationId).catch(
-      () => {},
-    );
+    if (!discardedResumableSession || cleanupClaim) {
+      await deleteResumableSession(recordingId, discardedGenerationId).catch(
+        () => {},
+      );
+    }
 
     let uploadMode: UploadMode = "buffered";
     let compensateStartedSession: (() => Promise<void>) | null = null;

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

@@ -26,6 +26,15 @@ const schema = databaseMutationEnvelopeSchema.extend({
 export default defineAction({
   description:
     "Create one row in an exact ordinary Content database using its discovered schema revision. Strictly validates every non-Blocks property, applies the side effect once per idempotency key, and returns a verified receipt with stable row identity.",
+  publicAgent: {
+    expose: true,
+    readOnly: false,
+    requiresAuth: true,
+    isConsequential: true,
+    title: "Add Content Database Item",
+    description:
+      "Delegate creation of one page item in an existing Content database.",
+  },
   schema,
   audit: {
     recordInputs: false,

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

@@ -0,0 +1,92 @@
+import { defineAction } from "@agent-native/core";
+import { accessFilter } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { getDocumentContextPath } from "../server/lib/document-context.js";
+import type {
+  ContentDatabaseDescriptionResponse,
+  ContentDatabaseUnavailableResponse,
+} from "../shared/api.js";
+import { resolveContentDatabaseRead } from "./_database-utils.js";
+import {
+  listPropertiesForDatabase,
+  serializeDatabase,
+} from "./_property-utils.js";
+import listContentDatabases, {
+  ContentDatabaseResolutionError,
+} from "./list-content-databases.js";
+
+export default defineAction({
+  description:
+    "Describe one exact ordinary Content database, including its live metadata, views, and property schema but not its rows. Resolve the stable database or document ID with list-content-databases first.",
+  schema: z
+    .object({
+      databaseId: z.string().min(1).optional().describe("Exact database ID"),
+      documentId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Exact database document/page ID"),
+    })
+    .refine(
+      (input) => Boolean(input.databaseId) !== Boolean(input.documentId),
+      "Provide exactly one of databaseId or documentId.",
+    ),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async ({
+    databaseId,
+    documentId,
+  }): Promise<
+    ContentDatabaseDescriptionResponse | ContentDatabaseUnavailableResponse
+  > => {
+    let selection: Awaited<ReturnType<typeof listContentDatabases.run>>;
+    try {
+      selection = await listContentDatabases.run({ databaseId, documentId });
+    } catch (error) {
+      if (!(error instanceof ContentDatabaseResolutionError)) throw error;
+      throw new Error("Content database not found.");
+    }
+    const selected = selection.databases[0];
+    if (!selected) throw new Error("Content database not found.");
+
+    const resolved = await resolveContentDatabaseRead({
+      databaseId: selected.databaseId,
+    });
+    if (!resolved.available) return resolved;
+    if (resolved.database.systemRole) {
+      throw new Error("Content database not found.");
+    }
+
+    const db = getDb();
+    const [databaseDocument] = await db
+      .select({
+        id: schema.documents.id,
+        parentId: schema.documents.parentId,
+      })
+      .from(schema.documents)
+      .where(
+        and(
+          eq(schema.documents.id, selected.documentId),
+          accessFilter(schema.documents, schema.documentShares),
+        ),
+      );
+    if (!databaseDocument) throw new Error("Content database not found.");
+
+    const [properties, contextPath] = await Promise.all([
+      listPropertiesForDatabase(resolved.database.id),
+      getDocumentContextPath(databaseDocument),
+    ]);
+    return {
+      database: serializeDatabase(
+        { ...resolved.database, title: selected.title },
+        selected.description,
+      ),
+      contextPath,
+      properties,
+    };
+  },
+});